From f73828d98a5062a0d9fc988a859c3af1cd011b16 Mon Sep 17 00:00:00 2001 From: Valerio Rico <5669698+V-Rico@users.noreply.github.com> Date: Thu, 22 Jun 2023 15:14:24 +0300 Subject: [PATCH] Initial commit --- .coveragerc | 26 + .dockerignore | 32 + .env.dev | 21 + .env.override.example | 9 + .flake8 | 14 + .github/workflows/docker-publish.yml | 45 + .gitignore | 152 + .readthedocs.yaml | 21 + CONTRIBUTORS.md | 10 + Dockerfile | 43 + LICENSE.txt | 21 + Makefile | 89 + README.md | 41 + app/__init__.py | 24 + app/config.yml | 34 + app/exceptions/__init__.py | 0 app/exceptions/api_errors.py | 309 ++ app/exceptions/handlers.py | 49 + app/exceptions/schemas.py | 15 + app/logging.yml | 23 + app/main.py | 194 ++ app/metrics/__init__.py | 0 app/metrics/celery.py | 32 + app/metrics/common.py | 56 + app/metrics/constants.py | 1 + app/metrics/db/__init__.py | 17 + app/metrics/db/base.py | 74 + app/metrics/db/sqlalchemy.py | 270 ++ app/metrics/http_in.py | 93 + app/metrics/http_out.py | 73 + app/metrics/job.py | 21 + app/metrics/server.py | 170 + app/routers/__init__.py | 0 app/routers/gitlab.py | 73 + app/routers/healthcheck.py | 14 + app/routers/metrics.py | 20 + app/routers/security.py | 56 + app/secbot/__init__.py | 93 + app/secbot/alembic.ini | 103 + app/secbot/config.py | 198 ++ app/secbot/db/__init__.py | 49 + app/secbot/db/alembic/__init__.py | 0 app/secbot/db/alembic/env.py | 83 + app/secbot/db/alembic/script.py.mako | 24 + .../alembic/versions/3611bb3d9dd2_initial.py | 90 + app/secbot/db/alembic/versions/__init__.py | 0 app/secbot/db/models.py | 2 + app/secbot/exceptions.py | 49 + app/secbot/handlers.py | 158 + app/secbot/inputs/__init__.py | 192 ++ app/secbot/inputs/gitlab/__init__.py | 127 + app/secbot/inputs/gitlab/dependencies.py | 376 +++ app/secbot/inputs/gitlab/handlers/__init__.py | 0 .../gitlab/handlers/defectdojo/__init__.py | 88 + .../inputs/gitlab/handlers/defectdojo/api.py | 767 +++++ .../gitlab/handlers/defectdojo/services.py | 326 ++ .../gitlab/handlers/defectdojo/validator.py | 141 + .../gitlab/handlers/gitleaks/__init__.py | 107 + .../inputs/gitlab/handlers/slack/__init__.py | 85 + .../inputs/gitlab/handlers/slack/api.py | 15 + .../inputs/gitlab/handlers/slack/utils.py | 57 + app/secbot/inputs/gitlab/models.py | 80 + app/secbot/inputs/gitlab/schemas/__init__.py | 70 + app/secbot/inputs/gitlab/schemas/base.py | 67 + .../inputs/gitlab/schemas/merge_request.py | 44 + .../inputs/gitlab/schemas/output_responses.py | 21 + app/secbot/inputs/gitlab/schemas/push.py | 28 + app/secbot/inputs/gitlab/schemas/tag.py | 32 + app/secbot/inputs/gitlab/services.py | 310 ++ app/secbot/inputs/gitlab/utils.py | 88 + app/secbot/logger.py | 4 + app/secbot/schemas.py | 77 + app/secbot/settings.py | 11 + app/secbot/utils.py | 48 + app/settings.py | 68 + docker-compose.yml | 64 + docker-entrypoint.sh | 80 + docs/Makefile | 20 + docs/conf.py | 37 + docs/configuration.rst | 204 ++ docs/getting-started.rst | 127 + docs/glossary.rst | 98 + docs/images/defectdojo-user.png | Bin 0 -> 119961 bytes docs/images/general-scheme.drawio | 216 ++ docs/images/general-scheme.drawio.png | Bin 0 -> 73881 bytes docs/images/gitlab-access-token.png | Bin 0 -> 255907 bytes docs/images/gitlab-system-hooks.png | Bin 0 -> 103936 bytes docs/images/job-graph.drawio | 1 + docs/images/job-graph.drawio.png | Bin 0 -> 39013 bytes docs/images/slack-dashboard.png | Bin 0 -> 388800 bytes docs/index.rst | 57 + docs/integration.rst | 185 ++ docs/make.bat | 35 + k8s/configmap.yml | 62 + k8s/deployment.yml | 173 ++ k8s/ingress.yml | 30 + k8s/sec-bot-tls-certs.yml | 9 + k8s/service.yml | 47 + poetry.lock | 2756 +++++++++++++++++ pyproject.toml | 106 + static/security-bot-logo.png | Bin 0 -> 68070 bytes tests/__init__.py | 0 tests/conftest.py | 42 + .../inputs/gitlab/merge_request_webhook.json | 141 + .../fixtures/inputs/gitlab/push_webhook.json | 84 + .../inputs/gitlab/tag_push_webhook.json | 60 + .../merge_request_hook__example_project.json | 127 + .../merge_request_hook__public_site.json | 127 + .../merge_request_hook__security_bot.json | 127 + tests/fixtures/worker_outputs/gitleaks.json | 20 + tests/integration/__init__.py | 0 tests/integration/notifications/__init__.py | 0 tests/integration/notifications/test_slack.py | 64 + tests/integration/test_outputs.py | 53 + tests/pytest.ini | 3 + tests/test_logger.py | 12 + tests/test_sentry.py | 25 + tests/test_settings.py | 6 + tests/units/__init__.py | 0 tests/units/common.py | 5 + tests/units/config/__init__.py | 0 tests/units/config/test_config_v1_parser.py | 142 + .../config/test_secbot_config_version.py | 27 + tests/units/factories.py | 69 + tests/units/inputs/__init__.py | 0 tests/units/inputs/config/__init__.py | 0 .../units/inputs/config/test_config_utils.py | 7 + tests/units/inputs/config/test_parse_jobs.py | 115 + tests/units/inputs/conftest.py | 46 + tests/units/inputs/gitlab/__init__.py | 0 .../units/inputs/gitlab/handlers/__init__.py | 0 .../inputs/gitlab/handlers/slack/__init__.py | 0 .../slack/test_slack_message_generation.py | 110 + .../gitlab/test_defectdojo_validation.py | 119 + .../inputs/gitlab/test_gitlab_dependencies.py | 90 + .../gitlab/test_gitlab_project_languages.py | 76 + .../units/inputs/gitlab/test_gitlab_routes.py | 23 + .../units/inputs/gitlab/test_gitlab_utils.py | 46 + .../gitlab/test_merge_request_webhook_data.py | 30 + .../inputs/gitlab/test_push_webhook_data.py | 53 + .../gitlab/test_tag_push_webhook_data.py | 53 + tests/units/secbot/__init__.py | 0 tests/units/secbot/test_autodiscover.py | 20 + tests/units/secbot/test_register.py | 37 + tests/units/test_pydantic_celery.py | 95 + tests/units/test_worker_utils.py | 22 + tests/units/workflow/test_workflow_runner.py | 95 + 147 files changed, 12698 insertions(+) create mode 100755 .coveragerc create mode 100755 .dockerignore create mode 100755 .env.dev create mode 100755 .env.override.example create mode 100755 .flake8 create mode 100644 .github/workflows/docker-publish.yml create mode 100755 .gitignore create mode 100755 .readthedocs.yaml create mode 100755 CONTRIBUTORS.md create mode 100755 Dockerfile create mode 100755 LICENSE.txt create mode 100755 Makefile create mode 100755 README.md create mode 100755 app/__init__.py create mode 100755 app/config.yml create mode 100755 app/exceptions/__init__.py create mode 100755 app/exceptions/api_errors.py create mode 100755 app/exceptions/handlers.py create mode 100755 app/exceptions/schemas.py create mode 100755 app/logging.yml create mode 100755 app/main.py create mode 100755 app/metrics/__init__.py create mode 100755 app/metrics/celery.py create mode 100755 app/metrics/common.py create mode 100755 app/metrics/constants.py create mode 100755 app/metrics/db/__init__.py create mode 100755 app/metrics/db/base.py create mode 100755 app/metrics/db/sqlalchemy.py create mode 100755 app/metrics/http_in.py create mode 100755 app/metrics/http_out.py create mode 100755 app/metrics/job.py create mode 100755 app/metrics/server.py create mode 100755 app/routers/__init__.py create mode 100755 app/routers/gitlab.py create mode 100755 app/routers/healthcheck.py create mode 100755 app/routers/metrics.py create mode 100755 app/routers/security.py create mode 100755 app/secbot/__init__.py create mode 100755 app/secbot/alembic.ini create mode 100755 app/secbot/config.py create mode 100755 app/secbot/db/__init__.py create mode 100755 app/secbot/db/alembic/__init__.py create mode 100755 app/secbot/db/alembic/env.py create mode 100755 app/secbot/db/alembic/script.py.mako create mode 100755 app/secbot/db/alembic/versions/3611bb3d9dd2_initial.py create mode 100755 app/secbot/db/alembic/versions/__init__.py create mode 100755 app/secbot/db/models.py create mode 100755 app/secbot/exceptions.py create mode 100755 app/secbot/handlers.py create mode 100755 app/secbot/inputs/__init__.py create mode 100755 app/secbot/inputs/gitlab/__init__.py create mode 100755 app/secbot/inputs/gitlab/dependencies.py create mode 100755 app/secbot/inputs/gitlab/handlers/__init__.py create mode 100755 app/secbot/inputs/gitlab/handlers/defectdojo/__init__.py create mode 100755 app/secbot/inputs/gitlab/handlers/defectdojo/api.py create mode 100755 app/secbot/inputs/gitlab/handlers/defectdojo/services.py create mode 100755 app/secbot/inputs/gitlab/handlers/defectdojo/validator.py create mode 100755 app/secbot/inputs/gitlab/handlers/gitleaks/__init__.py create mode 100755 app/secbot/inputs/gitlab/handlers/slack/__init__.py create mode 100755 app/secbot/inputs/gitlab/handlers/slack/api.py create mode 100755 app/secbot/inputs/gitlab/handlers/slack/utils.py create mode 100755 app/secbot/inputs/gitlab/models.py create mode 100755 app/secbot/inputs/gitlab/schemas/__init__.py create mode 100755 app/secbot/inputs/gitlab/schemas/base.py create mode 100755 app/secbot/inputs/gitlab/schemas/merge_request.py create mode 100755 app/secbot/inputs/gitlab/schemas/output_responses.py create mode 100755 app/secbot/inputs/gitlab/schemas/push.py create mode 100755 app/secbot/inputs/gitlab/schemas/tag.py create mode 100755 app/secbot/inputs/gitlab/services.py create mode 100755 app/secbot/inputs/gitlab/utils.py create mode 100755 app/secbot/logger.py create mode 100755 app/secbot/schemas.py create mode 100755 app/secbot/settings.py create mode 100755 app/secbot/utils.py create mode 100755 app/settings.py create mode 100755 docker-compose.yml create mode 100755 docker-entrypoint.sh create mode 100755 docs/Makefile create mode 100755 docs/conf.py create mode 100755 docs/configuration.rst create mode 100755 docs/getting-started.rst create mode 100755 docs/glossary.rst create mode 100755 docs/images/defectdojo-user.png create mode 100755 docs/images/general-scheme.drawio create mode 100755 docs/images/general-scheme.drawio.png create mode 100755 docs/images/gitlab-access-token.png create mode 100755 docs/images/gitlab-system-hooks.png create mode 100755 docs/images/job-graph.drawio create mode 100755 docs/images/job-graph.drawio.png create mode 100755 docs/images/slack-dashboard.png create mode 100755 docs/index.rst create mode 100755 docs/integration.rst create mode 100755 docs/make.bat create mode 100644 k8s/configmap.yml create mode 100644 k8s/deployment.yml create mode 100644 k8s/ingress.yml create mode 100644 k8s/sec-bot-tls-certs.yml create mode 100644 k8s/service.yml create mode 100755 poetry.lock create mode 100755 pyproject.toml create mode 100755 static/security-bot-logo.png create mode 100755 tests/__init__.py create mode 100755 tests/conftest.py create mode 100755 tests/fixtures/inputs/gitlab/merge_request_webhook.json create mode 100755 tests/fixtures/inputs/gitlab/push_webhook.json create mode 100755 tests/fixtures/inputs/gitlab/tag_push_webhook.json create mode 100755 tests/fixtures/merge_request_hook__example_project.json create mode 100755 tests/fixtures/merge_request_hook__public_site.json create mode 100755 tests/fixtures/merge_request_hook__security_bot.json create mode 100755 tests/fixtures/worker_outputs/gitleaks.json create mode 100755 tests/integration/__init__.py create mode 100755 tests/integration/notifications/__init__.py create mode 100755 tests/integration/notifications/test_slack.py create mode 100755 tests/integration/test_outputs.py create mode 100755 tests/pytest.ini create mode 100755 tests/test_logger.py create mode 100755 tests/test_sentry.py create mode 100755 tests/test_settings.py create mode 100755 tests/units/__init__.py create mode 100755 tests/units/common.py create mode 100755 tests/units/config/__init__.py create mode 100755 tests/units/config/test_config_v1_parser.py create mode 100755 tests/units/config/test_secbot_config_version.py create mode 100755 tests/units/factories.py create mode 100755 tests/units/inputs/__init__.py create mode 100755 tests/units/inputs/config/__init__.py create mode 100755 tests/units/inputs/config/test_config_utils.py create mode 100755 tests/units/inputs/config/test_parse_jobs.py create mode 100755 tests/units/inputs/conftest.py create mode 100755 tests/units/inputs/gitlab/__init__.py create mode 100755 tests/units/inputs/gitlab/handlers/__init__.py create mode 100755 tests/units/inputs/gitlab/handlers/slack/__init__.py create mode 100755 tests/units/inputs/gitlab/handlers/slack/test_slack_message_generation.py create mode 100755 tests/units/inputs/gitlab/test_defectdojo_validation.py create mode 100755 tests/units/inputs/gitlab/test_gitlab_dependencies.py create mode 100755 tests/units/inputs/gitlab/test_gitlab_project_languages.py create mode 100755 tests/units/inputs/gitlab/test_gitlab_routes.py create mode 100755 tests/units/inputs/gitlab/test_gitlab_utils.py create mode 100755 tests/units/inputs/gitlab/test_merge_request_webhook_data.py create mode 100755 tests/units/inputs/gitlab/test_push_webhook_data.py create mode 100755 tests/units/inputs/gitlab/test_tag_push_webhook_data.py create mode 100755 tests/units/secbot/__init__.py create mode 100755 tests/units/secbot/test_autodiscover.py create mode 100755 tests/units/secbot/test_register.py create mode 100755 tests/units/test_pydantic_celery.py create mode 100755 tests/units/test_worker_utils.py create mode 100755 tests/units/workflow/test_workflow_runner.py diff --git a/.coveragerc b/.coveragerc new file mode 100755 index 0000000..cf1b27a --- /dev/null +++ b/.coveragerc @@ -0,0 +1,26 @@ +[run] +omit = tests/*, app/alembic/*, **/exceptions.py + +[report] +fail_under = 60 +# Regexes for lines to exclude from consideration +exclude_lines = + # Have to re-enable the standard pragma + pragma: no cover + + # Don't complain about missing debug-only code: + def __repr__ + if self\.debug + + # Don't complain if tests don't hit defensive assertion code: + raise AssertionError + raise NotImplementedError + + # Don't complain if non-runnable code isn't run: + if 0: + if __name__ == .__main__.: + + # Don't complain about abstract methods, they aren't run: + @(abc\.)?abstractmethod + +ignore_errors = True diff --git a/.dockerignore b/.dockerignore new file mode 100755 index 0000000..ebde079 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,32 @@ +.idea +.cache +.coverage +.dockerignore +.git +.gitattributes +.gitignore +.gitkeep +.flake8 +.isort.cfg +.mypy_cache +.pytest_cache +.tox +tox.ini +mypy.ini +tests +distribution +venv +**/__pycache__ +*.yml +*.svg +*.egg-info/ +*.egg +env/ +pytest.ini +README.rst +README.md +Dockerfile +Zenvfile +infrastructure +data/ +.env.override.example diff --git a/.env.dev b/.env.dev new file mode 100755 index 0000000..6004e9b --- /dev/null +++ b/.env.dev @@ -0,0 +1,21 @@ +UVICORN_RELOAD=1 + +CELERY_BROKER_URL=redis://redis:6379/0 +CELERY_RESULT_BACKEND=redis://redis:6379/0 + +SECBOT_POSTGRES_DSN=postgresql+asyncpg://secbot:foobar@db:5432/secbot + +GITLAB_CONFIGS=[{"host":"https://git.env.local/","webhook_secret_token":"SecretStr","auth_token":"SecretStr","prefix":"GIT_LOCAL"}] + +DEFECTDOJO__URL=https://defectdojo.env.local +DEFECTDOJO__TOKEN=defectdojo_token +DEFECTDOJO__USER=defectdojo_username +DEFECTDOJO__USER_ID=10 + +SLACK_TOKEN=token_here + +# Metrics settings +SRE_METRIC_LABEL_TEAM=SECURITY +SRE_METRIC_LABEL_SERVICE=security-bot +TRACING_TAGS_HOST=security-bot.env.local +TRACING_TAGS_CLUSTER=security-local diff --git a/.env.override.example b/.env.override.example new file mode 100755 index 0000000..adcf53e --- /dev/null +++ b/.env.override.example @@ -0,0 +1,9 @@ +# The .env.override.example file streamlines environment-specific settings management during development. +# +# To use it: +# 1. Rename the file to '.env.override' for recognition by the dev environment. +# 2. Update environment variables with development-specific values in the file. +# 3. Rebuild the Docker image and restart it, ensuring it reads from the updated .env.override. +# +# e.g. +# DEBUG=true diff --git a/.flake8 b/.flake8 new file mode 100755 index 0000000..bb6fb2d --- /dev/null +++ b/.flake8 @@ -0,0 +1,14 @@ +[flake8] +max-line-length = 87 +ignore = E203,W503,E501,W293 +statistics = True +exclude = + .git, + __pycache__, + .cache/, + .pytest_cache/, + .mypy_cache/, + .venv/, + .run/, + app/secbot/db/alembic + diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml new file mode 100644 index 0000000..d56f839 --- /dev/null +++ b/.github/workflows/docker-publish.yml @@ -0,0 +1,45 @@ +name: Publish Docker image + +on: + release: + types: [published] + +jobs: + push_to_registries: + name: Push Docker image + runs-on: ubuntu-latest + permissions: + packages: write + contents: read + steps: + - name: Check out the repo + uses: actions/checkout@v3 + + - name: Log in to Docker Hub + uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Log in to the Container registry + uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1 + with: + registry: ghcr.io + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Extract metadata (tags, labels) for Docker + id: meta + uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7 + with: + images: | + exness/security-bot + ghcr.io/${{ github.repository }} + + - name: Build and push Docker images + uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671 + with: + context: . + push: true + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..54cd7e0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,152 @@ +# 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 + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Personal override env +.env.override + +# 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 +.idea/ +.DS_Store diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100755 index 0000000..1fdea58 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,21 @@ +version: 2 + +build: + os: "ubuntu-20.04" + tools: + python: "3.9" + jobs: + post_create_environment: + - pip install --upgrade pip + - pip install poetry + - poetry config virtualenvs.create false + post_install: + - poetry install --no-root + +formats: + - pdf + - epub + +sphinx: + configuration: docs/conf.py + fail_on_warning: true diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md new file mode 100755 index 0000000..dfddab0 --- /dev/null +++ b/CONTRIBUTORS.md @@ -0,0 +1,10 @@ +# Special thanks + +- [Exness](https://github.com/exness) +- [Vulners](https://github.com/vulnerscom) + +# Contributors + +- [Valerio Rico](https://github.com/V-Rico) - MVP and maintenance +- [Ivan Zhirov](https://github.com/izhirov) - further development and maintenance +- [Maxim Sokolov](https://github.com/mcson-the-writer) - documentation diff --git a/Dockerfile b/Dockerfile new file mode 100755 index 0000000..36a3e4b --- /dev/null +++ b/Dockerfile @@ -0,0 +1,43 @@ +FROM python:3.9-slim + +ARG USER_NAME="exness" +ARG USER_HOME="/${USER_NAME}" +ARG APP_HOME="/opt" + +COPY poetry.lock pyproject.toml / + +### Add required binaries ### +RUN apt-get update && \ + apt-get install -y git curl && \ + apt-get clean && \ + rm -rf /var/cache/* + +RUN apt-get update && \ + apt-get install -qy --no-install-recommends build-essential make && \ + pip install --no-cache-dir --upgrade pip poetry>=1.0.0 && \ + poetry config virtualenvs.create false && \ + poetry install --no-interaction --no-dev && \ + apt-get remove -qy --purge build-essential && \ + apt-get autoremove --purge -qy && \ + apt-get clean && \ + rm -rf /var/cache/* /poetry.lock /pyproject.toml + +### Add worker tools ### + +# Install gitleaks +COPY --from=zricethezav/gitleaks:v8.17.0 /usr/bin/gitleaks /usr/local/bin/gitleaks + +### Create service user ### +RUN groupadd -g 10001 ${USER_NAME} && useradd -g 10001 -u 10001 -s "/usr/sbin/nologin" -md ${USER_HOME} ${USER_NAME} + +### Add application source code ### +COPY docker-entrypoint.sh /usr/local/bin +COPY --chown=10001:10001 app/ ${APP_HOME}/app + +ENV PYTHONPATH="${APP_HOME}" + +USER ${USER_NAME} +EXPOSE 5000 5001 +WORKDIR ${APP_HOME} +ENTRYPOINT ["docker-entrypoint.sh"] +CMD ["help"] diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100755 index 0000000..b336733 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Exness + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Makefile b/Makefile new file mode 100755 index 0000000..22253b2 --- /dev/null +++ b/Makefile @@ -0,0 +1,89 @@ +.PHONY: help + +CURRENT_DIR = $(shell pwd) +GREEN = \033[0;32m +YELLOW = \033[0;33m +NC = \033[0m + +APP_HOST := $(or ${APP_HOST},${APP_HOST},0.0.0.0) +APP_PORT := $(or ${APP_PORT},${APP_PORT},5000) +PYTHONPATH := $(or ${PYTHONPATH},${PYTHONPATH},.) + +help: + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-17s\033[0m %s\n", $$1, $$2}' + +# ============= General use-cases ============= + +start-up: dependencies-up install migrate start ## Start service from zero +check: linting test ## Linting python code and run tests in one command + +# ============= General commands ============= + +install: ## Install all dependencies (need poetry!) + @echo "\n${GREEN}Installing project dependencies${NC}" + pip install --force-reinstall poetry + poetry install + +dependencies-up: ## Pull and start the Docker containers with dependencies in the background + @echo "\n${GREEN}Start the Docker containers with dependencies${NC}" + docker compose up -d + + +dependencies-down: ## Down the Docker containers with dependencies + @echo "\n${GREEN}Down the Docker containers with dependencies${NC}" + docker-compose down + +clean: dependencies-down ## Clear temporary information, stop Docker containers + @echo "\n${YELLOW}Clear cache directories${NC}" + rm -rf .mypy_cache .pytest_cache .coverage + poetry run pyclean . + + +start: ## Run applications + @echo "Starting test webserver..." + python -m \ + uvicorn app.main:app --host ${APP_HOST} --port ${APP_PORT} + +test-webserver: + @echo "Starting test webserver..." + python -m \ + uvicorn app.main:app --host ${APP_HOST} --port ${APP_PORT} --reload --reload-dir=./app + +test: + pytest ${TARGET} + +fmt: ## Auto formatting python code + @echo "\n${GREEN}Auto formatting python code with isort${NC}" + poetry run isort . || true + @echo "\n${GREEN}Auto formatting python code with black${NC}" + poetry run black . || true + +linting: flake8 isort black mypy ## Linting python code + +# ============= Other project specific commands ============= + +flake8: ## Linting python code with flake8 + @echo "\n${GREEN}Linting python code with flake8${NC}" + poetry run flake8 . + +isort: ## Linting python code with isort + @echo "\n${GREEN}Linting python code with isort${NC}" + poetry run isort app --check + +black: ## Linting python code with black + @echo "\n${GREEN}Linting python code with black${NC}" + poetry run black --check app + +mypy: ## Linting python code with mypy + @echo "\n${GREEN}Linting python code with mypy${NC}" + poetry run mypy app --check-untyped-defs + +# Database commands +new_revision: ## Create new revision + docker compose exec app alembic -c /opt/app/secbot/alembic.ini revision --autogenerate -m "${MESSAGE}" + +migrate: ## Migrate the database + docker compose exec app alembic -c /opt/app/secbot/alembic.ini upgrade head + +downgrade: ## Downgrade the database + docker compose exec app alembic -c /opt/app/secbot/alembic.ini downgrade -1 diff --git a/README.md b/README.md new file mode 100755 index 0000000..44f91bf --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +![security-bot](static/security-bot-logo.png) + +Security Bot - Security checks orchestration tool +======= + +[![python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390) +[![code style: black](https://img.shields.io/badge/code%20style-black-black.svg)](https://github.com/ambv/black) +[![code style: flake8](https://img.shields.io/badge/code%20style-flake8-blue.svg)](https://github.com/PyCQA/flake8) + +The [Security Bot](docs/index.rst) (SecBot) service introduces an additional collection of checks to the SDLC to identify security issues in corporate assets + +Reach out to our [Discord server](https://discordapp.com/invite/MqHBT6mg) to communicate with the team more effectively + +[![Discord Server](https://discordapp.com/api/guilds/1113355944101957703/widget.png?style=banner3)](https://discordapp.com/invite/MqHBT6mg) + +**Technologies: [FastAPI](https://fastapi.tiangolo.com/), [Celery](https://docs.celeryq.dev/en/stable/) + Redis, [SQLAlchemy](https://www.sqlalchemy.org/) + Postgres, Pytest, and others** + +## Installation and Tests + +#### For sample k8s manifests please refer to [/k8s](/k8s) directory + +Deployment: + + git clone path/to/project.git + docker-compose up --build + +Service configuration: + + .env.dev (Default values) + .env.override (Customized values) + +Workflow configuration: + + app/config.yml + +## Usage and Support + +Documentation: + +* [Project documentation (rtd)](https://security-bot.readthedocs.io/en/latest/) +* [Project documentation (local)](docs/index.rst) diff --git a/app/__init__.py b/app/__init__.py new file mode 100755 index 0000000..14f6cc1 --- /dev/null +++ b/app/__init__.py @@ -0,0 +1,24 @@ +import logging +from typing import Optional + +from celery.app.log import TaskFormatter + + +def format_extra(message, extra: Optional[dict] = None): + """Format extra keys from record.__dict__""" + if not extra: + return message + extra_str = ", ".join(f"{k}={str(v)[:15]}" for k, v in extra.items()) + return f"{message} EXTRA: {extra_str}" + + +class ExtraLogFormatter(logging.Formatter): + def format(self, record): + message = super().format(record) + return format_extra(message, record.__dict__) + + +class ExtraTaskFormatter(TaskFormatter): + def format(self, record): + message = super().format(record) + return format_extra(message, record.__dict__) diff --git a/app/config.yml b/app/config.yml new file mode 100755 index 0000000..1527f12 --- /dev/null +++ b/app/config.yml @@ -0,0 +1,34 @@ +version: 1.0 + +components: + gitleaks: + handler_name: "gitleaks" + config: + format: "json" + defectdojo: + handler_name: "defectdojo" + env: + url: "DEFECTDOJO__URL" + secret_key: "DEFECTDOJO__TOKEN" + user: "DEFECTDOJO__USER" + lead_id: "DEFECTDOJO__USER_ID" + slack: + handler_name: "slack" + config: + render_limit: 10 + channels: + - secbot-test + env: + token: "SLACK_TOKEN" + +jobs: + - name: Just example of merge request test + rules: + gitlab: + event_type: "merge_request" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack diff --git a/app/exceptions/__init__.py b/app/exceptions/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/exceptions/api_errors.py b/app/exceptions/api_errors.py new file mode 100755 index 0000000..05ed4e3 --- /dev/null +++ b/app/exceptions/api_errors.py @@ -0,0 +1,309 @@ +from typing import Dict, List, Optional, Type + +from app.exceptions.schemas import ValidationError, ValidationErrorDetail + + +class APIError(Exception): + status_code = 500 + default_code = "SERVER_ERROR" + default_message = "A server error occurred." + + _registry: Dict[int, Type["APIError"]] = {} + + def __init_subclass__(cls, register: bool = False, **kwargs): + if register is True: + cls._registry[cls.status_code] = cls + super().__init_subclass__(**kwargs) # type: ignore + + def __init__( + self, + code: Optional[str] = None, + message: Optional[str] = None, + details: Optional[List[ValidationErrorDetail]] = None, + ): + self.info = ValidationError( + code=code or self.default_code, + message=message or self.default_message, + details=details, + ) + super().__init__() + + def __repr__(self): + return ( + f"{self.__class__.__name__}(" + f"code='{self.info.code}'," + f" message='{self.info.message}'," + f" details={self.info.details}" + f")" + ) + + @classmethod + def get_cls_by_code(cls, status_code: int) -> Type["APIError"]: + return cls._registry.get(status_code, APIError) + + def as_dict(self): + return self.info.dict() + + +class BadRequest(APIError, register=True): + status_code = 400 + default_code = "BAD_REQUEST" + default_message = "Bad request." + + +class Unauthorized(APIError, register=True): + status_code = 401 + default_code = "UNAUTHORIZED" + default_message = "Unauthorized." + + +class PaymentRequired(APIError, register=True): + status_code = 402 + default_code = "PAYMENT_REQUIRED" + default_message = "Payment required." + + +class Forbidden(APIError, register=True): + status_code = 403 + default_code = "FORBIDDEN" + default_message = "Forbidden." + + +class NotFound(APIError, register=True): + status_code = 404 + default_code = "NOT_FOUND" + default_message = "Not found." + + +class MethodNotAllowed(APIError, register=True): + status_code = 405 + default_code = "METHOD_NOT_ALLOWED" + default_message = "Method not allowed." + + +class NotAcceptable(APIError, register=True): + status_code = 406 + default_code = "NOT_ACCEPTABLE" + default_message = "Not acceptable." + + +class ProxyAuthenticationRequired(APIError, register=True): + status_code = 407 + default_code = "PROXY_AUTHENTICATION_REQUIRED" + default_message = "Proxy authentication required." + + +class RequestTimeout(APIError, register=True): + status_code = 408 + default_code = "REQUEST_TIMEOUT" + default_message = "Request timeout." + + +class Conflict(APIError, register=True): + status_code = 409 + default_code = "CONFLICT" + default_message = "Conflict." + + +class Gone(APIError, register=True): + status_code = 410 + default_code = "GONE" + default_message = "Gone." + + +class LengthRequired(APIError, register=True): + status_code = 411 + default_code = "LENGTH_REQUIRED" + default_message = "Length required." + + +class PreconditionFailed(APIError, register=True): + status_code = 412 + default_code = "PRECONDITION_FAILED" + default_message = "Precondition failed." + + +class RequestEntityTooLarge(APIError, register=True): + status_code = 413 + default_code = "REQUEST_ENTITY_TOO_LARGE" + default_message = "Request entity too large." + + +class RequestURITooLong(APIError, register=True): + status_code = 414 + default_code = "REQUEST_URI_TOO_LONG" + default_message = "Request URI too long." + + +class UnsupportedMediaType(APIError, register=True): + status_code = 415 + default_code = "UNSUPPORTED_MEDIA_TYPE" + default_message = "Unsupported media type." + + +class RequestRangeNotSatisfiable(APIError, register=True): + status_code = 416 + default_code = "REQUEST_RANGE_NOT_SATISFIABLE" + default_message = "Request range not satisfiable." + + +class ExpectationFailed(APIError, register=True): + status_code = 417 + default_code = "EXPECTATION_FAILED" + default_message = "Expectation failed." + + +class IAmTeapot(APIError, register=True): + status_code = 418 + default_code = "I_AM_A_TEAPOT" + default_message = "I'm a teapot." + + +class EnhanceYourCalm(APIError, register=True): + status_code = 420 + default_code = "ENHANCE_YOUR_CALM" + default_message = "Enhance your calm." + + +class Misdirected(APIError, register=True): + status_code = 421 + default_code = "MISDIRECTED" + default_message = "The server is not able to produce a response." + + +class UnprocessableEntity(APIError, register=True): + status_code = 422 + default_code = "UNPROCESSABLE_ENTITY" + default_message = "Unprocessable entity." + + +class Locked(APIError, register=True): + status_code = 423 + default_code = "LOCKED" + default_message = "Locked." + + +class FailedDependency(APIError, register=True): + status_code = 424 + default_code = "FAILED_DEPENDENCY" + default_message = "Failed dependency." + + +class ReservedForWebDAV(APIError, register=True): + status_code = 425 + default_code = "RESERVED_FOR_WEBDAV" + default_message = "Reserved for WebDAV." + + +class UpgradeRequired(APIError, register=True): + status_code = 426 + default_code = "UPGRADE_REQUIRED" + default_message = "Upgrade required." + + +class PreconditionRequired(APIError, register=True): + status_code = 428 + default_code = "PRECONDITION_REQUIRED" + default_message = "Precondition required." + + +class TooManyRequests(APIError, register=True): + status_code = 429 + default_code = "TOO_MANY_REQUESTS" + default_message = "Too many requests." + + +class RequestHeaderFieldsTooLarge(APIError, register=True): + status_code = 431 + default_code = "REQUEST_HEADER_FIELDS_TOO_LARGE" + default_message = "Request header fields too large." + + +class UnavailableForLegalReasons(APIError, register=True): + status_code = 451 + default_code = "UNAVAILABLE_FOR_LEGAL_REASONS" + default_message = "Unavailable for legal reasons." + + +class ClientClosedRequest(APIError, register=True): + status_code = 499 + default_code = "CLIENT_CLOSED_REQUEST" + default_message = "Client closed request (nginx)." + + +class InternalServerError(APIError, register=True): + status_code = 500 + default_code = "INTERNAL_SERVER_ERROR" + default_message = "The server encountered an unexpected condition." + + +class ServerNotImplemented(APIError, register=True): + status_code = 501 + default_code = "NOT_IMPLEMENTED" + default_message = "Not implemented." + + +class BadGateway(APIError, register=True): + status_code = 502 + default_code = "BAD_GATEWAY" + default_message = "Bad gateway." + + +class Unavailable(APIError, register=True): + status_code = 503 + default_code = "SERVICE_UNAVAILABLE" + default_message = "Service is unavailable." + + +class GatewayTimeout(APIError, register=True): + status_code = 504 + default_code = "GATEWAY_TIMEOUT" + default_message = "Gateway timeout." + + +class HTTPVersionNotSupported(APIError, register=True): + status_code = 505 + default_code = "HTTP_VERSION_NOT_SUPPORTED" + default_message = "HTTP version not supported." + + +class VariantAlsoNegotiates(APIError, register=True): + status_code = 506 + default_code = "VARIANT_ALSO_NEGOTIATES" + default_message = "Variant also negotiates." + + +class InsufficientStorage(APIError, register=True): + status_code = 507 + default_code = "INSUFFICIENT_STORAGE" + default_message = "Insufficient storage." + + +class LoopDetected(APIError, register=True): + status_code = 508 + default_code = "LOOP_DETECTED" + default_message = "Loop detected." + + +class NotExtended(APIError, register=True): + status_code = 510 + default_code = "NOT_EXTENDED" + default_message = "Not extended." + + +class NetworkAuthenticationRequired(APIError, register=True): + status_code = 511 + default_code = "NETWORK_AUTHENTICATION_REQUIRED" + default_message = "Network authentication required." + + +class NetworkReadTimeoutError(APIError, register=True): + status_code = 598 + default_code = "NETWORK_READ_TIMEOUT_ERROR" + default_message = "Network read timeout error." + + +class NetworkConnectTimeoutError(APIError, register=True): + status_code = 599 + default_code = "NETWORK_CONNECT_TIMEOUT_ERROR" + default_message = "Network connect timeout error." diff --git a/app/exceptions/handlers.py b/app/exceptions/handlers.py new file mode 100755 index 0000000..f8d07e5 --- /dev/null +++ b/app/exceptions/handlers.py @@ -0,0 +1,49 @@ +from typing import TYPE_CHECKING, List, Union + +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException +from starlette.responses import JSONResponse + +from app.exceptions.api_errors import APIError +from app.exceptions.schemas import ValidationErrorDetail + +if TYPE_CHECKING: + from pydantic.error_wrappers import ErrorDict + + +async def api_error_exception_handler(_, starlette_exc: APIError): + return JSONResponse(starlette_exc.as_dict(), status_code=starlette_exc.status_code) + + +async def http_exception_handler(_, starlette_exc: HTTPException): + exc_class = APIError.get_cls_by_code(starlette_exc.status_code) + exc = exc_class(message=starlette_exc.detail) + return JSONResponse(exc.as_dict(), status_code=exc.status_code) + + +async def validation_exception_handler(_, starlette_exc: RequestValidationError): + exc_class = APIError.get_cls_by_code(400) + exc = exc_class( + "VALIDATION_FAILED", + details=normalize_details(starlette_exc.errors()), + ) + return JSONResponse(exc.as_dict(), status_code=exc.status_code) + + +def normalize_details(details: List["ErrorDict"]) -> List[ValidationErrorDetail]: + res = [] + for data in details: + field: Union[int, str] = ".".join( + [loc for loc in data["loc"][2:] if isinstance(loc, str)] + ) + if not field and isinstance(data["loc"], tuple) and len(data["loc"]) >= 2: + field = data["loc"][1] + + res.append( + ValidationErrorDetail( + code=data["type"].upper(), + field=field, + message=data["msg"], + ) + ) + return res diff --git a/app/exceptions/schemas.py b/app/exceptions/schemas.py new file mode 100755 index 0000000..e3e79f5 --- /dev/null +++ b/app/exceptions/schemas.py @@ -0,0 +1,15 @@ +from typing import List, Optional + +from pydantic import BaseModel + + +class ValidationErrorDetail(BaseModel): + code: str + field: str + message: str + + +class ValidationError(BaseModel): + code: Optional[str] = None + message: Optional[str] = None + details: Optional[List[ValidationErrorDetail]] = None diff --git a/app/logging.yml b/app/logging.yml new file mode 100755 index 0000000..c110c18 --- /dev/null +++ b/app/logging.yml @@ -0,0 +1,23 @@ +version: 1 +disable_existing_loggers: false + +formatters: + verbose: + "()": "app.ExtraLogFormatter" + format: '%(levelname)s %(asctime)s %(filename)s:%(funcName)s:%(lineno)d %(message)s' + +handlers: + console: + class: logging.StreamHandler + formatter: verbose + stream: ext://sys.stdout + +loggers: + uvicorn: + error: + propagate: true + +root: + level: INFO + handlers: [console] + propagate: no diff --git a/app/main.py b/app/main.py new file mode 100755 index 0000000..d05a800 --- /dev/null +++ b/app/main.py @@ -0,0 +1,194 @@ +import logging.config +import typing + +import sentry_sdk +import yaml +from celery import Celery +from celery.signals import after_setup_logger, after_setup_task_logger +from fastapi import APIRouter, FastAPI +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException + +from app import ExtraTaskFormatter +from app.exceptions.api_errors import APIError +from app.exceptions.handlers import ( + api_error_exception_handler, + http_exception_handler, + validation_exception_handler, +) +from app.exceptions.schemas import ValidationError +from app.metrics.celery import instrument as celery_metrics_instrument +from app.metrics.server import ASGIMetricsMiddleware +from app.routers import gitlab, healthcheck, metrics, security +from app.settings import BASE_PATH, flatten_settings_values, settings + + +def init_celery() -> Celery: + celery = Celery(__name__) + celery.conf.broker_url = settings.celery_broker_url + celery.conf.result_backend = settings.celery_result_backend + celery_metrics_instrument() + + return celery + + +def sanitize_event_values( + value: typing.Union[dict, list, tuple, str], + sensitive_values: typing.Set[typing.Union[str, int]], +) -> typing.Union[dict, list, tuple, str]: + """Sanitize a sentry event from sensitive values. + + A sentry event is a complex dictionary of problem information. + This function goes recursively over all strings and replaces + the sensitive ones with the word [Redacted] + """ + if isinstance(value, dict): + value = { + k: sanitize_event_values(v, sensitive_values) for k, v in value.items() + } + elif isinstance(value, list): + value = [sanitize_event_values(item, sensitive_values) for item in value] + elif isinstance(value, str): + for sens_value in sensitive_values: + sens_value = str(sens_value) + if sens_value in value: + value = value.replace(sens_value, "[Redacted]") + return value + + +def before_send(event, hint): + """Sentry hook before sending an error handler. + + If you need to change something before sending an event to the sentry this is the place. + https://docs.sentry.io/platforms/python/configuration/filtering/#filtering-error-events + + Here we redact all sensitive values from the event with + all env variables from the app settings object. + """ + settings_values = flatten_settings_values(app_settings=settings) + event = sanitize_event_values(event, sensitive_values=settings_values) + return event + + +def initial_secbot(celery_application): + """Initializes the secbot workflow runner with auto-discovery. + This process finds and registers workflow components. + + Although a workflow could run independently, it's advised to register and + execute it through the runner for proper management. + + Args: + celery_application: The Celery application for task management. + + Returns: + An initialized instance of the SecurityBot class. + """ + from app.secbot import SecurityBot + + return SecurityBot(celery_app=celery_application) + + +def init_app( + title: str, + routers: typing.List[APIRouter], + openapi_tags: typing.List[typing.Dict[str, typing.Any]] = None, +): + application = FastAPI( + title=title, + debug=settings.debug, + version="1.0.0", + docs_url="/docs" if settings.docs_enable else None, + openapi_tags=openapi_tags, + ) + + # Setup exceptions + application.add_exception_handler( + APIError, + api_error_exception_handler, + ) + application.add_exception_handler( + HTTPException, + http_exception_handler, + ) + application.add_exception_handler( + RequestValidationError, + validation_exception_handler, + ) + + # Setup routes + application.include_router(healthcheck.router) + + router_v1 = APIRouter( + prefix="/v1", + responses={ + 422: { + "model": ValidationError, + "description": "Validation Error", + } + }, + ) + for router in routers: + router_v1.include_router(router) + + application.include_router(router_v1) + + # Setup metrics + application.add_middleware( + ASGIMetricsMiddleware, + tier=1, + include_latency_histogram=True, + record_source_ip=True, + include_not_found_url_label=False, + ) + application.include_router(metrics.router) + + # Setup sentry + if settings.sentry_dsn: + sentry_sdk.init(dsn=settings.sentry_dsn, before_send=before_send) + + return application + + +with open(BASE_PATH / "logging.yml") as logging_yml: + logging_config = yaml.safe_load(logging_yml.read()) + logging.config.dictConfig(logging_config) + +app = init_app( + title=settings.app_name, + routers=[ + gitlab.router, + ], + openapi_tags=[ + {"name": "common"}, + { + "name": "gitlab", + "externalDocs": { + "description": "Gitlab webhook events", + "url": "https://docs.gitlab.com/ee/user/project/integrations/webhook_events.html", + }, + }, + ], +) +security_gateway_app = init_app( + title="Security Gateway", + routers=[security.router], + openapi_tags=[{"name": "common"}, {"name": "security"}], +) +celery_app = init_celery() +security_bot = initial_secbot(celery_app) + + +@after_setup_logger.connect +def setup_loggers(logger, *args, **kwargs): + with open(BASE_PATH / "logging.yml") as logging_yml: + logging_config = yaml.safe_load(logging_yml.read()) + logging.config.dictConfig(logging_config) + + +@after_setup_task_logger.connect +def setup_task_logger(logger, *args, **kwargs): + for handler in logger.handlers: + if handler.formatter: + # Change the formatter but leave the format be. + formatter = ExtraTaskFormatter(handler.formatter._fmt) + handler.setFormatter(formatter) diff --git a/app/metrics/__init__.py b/app/metrics/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/metrics/celery.py b/app/metrics/celery.py new file mode 100755 index 0000000..44d615d --- /dev/null +++ b/app/metrics/celery.py @@ -0,0 +1,32 @@ +import timeit + +from celery import signals + +from app.metrics.common import get_location_labels_from_env +from app.metrics.job import SRE_JOB_ERRORS, SRE_JOB_EXECUTION_TIME, SRE_JOB_EXECUTIONS + + +def prerun(task, *args, **kwargs): + task._started_at = timeit.default_timer() + + +def postrun(task, *args, **kwargs): + labels = get_location_labels_from_env() + labels["job_name"] = task.name + execution_time = int((timeit.default_timer() - task._started_at) * 1000) + SRE_JOB_EXECUTIONS.labels(**labels).inc() + SRE_JOB_EXECUTION_TIME.labels(**labels).inc(execution_time) + + +def on_error(exception, sender, *args, **kwargs): + labels = get_location_labels_from_env() + SRE_JOB_ERRORS.labels( + **labels, job_name=sender.name, job_error=type(exception).__qualname__ + ).inc() + + +def instrument(): + signals.task_prerun.connect(prerun, weak=False) + signals.task_postrun.connect(postrun, weak=False) + signals.task_failure.connect(on_error, weak=False) + signals.task_internal_error.connect(on_error, weak=False) diff --git a/app/metrics/common.py b/app/metrics/common.py new file mode 100755 index 0000000..04d664e --- /dev/null +++ b/app/metrics/common.py @@ -0,0 +1,56 @@ +import os +import typing +from sys import argv, executable + +from prometheus_client import REGISTRY, CollectorRegistry, start_http_server +from prometheus_client.multiprocess import MultiProcessCollector + +from app.metrics.constants import PROMETHEUS_MULTIPROC_DIR + + +class LocationLabels(typing.TypedDict): + dc: str + cluster: str + host: str + k8s_namespace: str + k8s_kind: str + k8s_pod: str + k8s_container: str + docker_container: str + os_process: str + os_process_cmdline: str + team: str + service: str + + +location_labels = tuple(LocationLabels.__annotations__) + + +def get_location_labels_from_env() -> LocationLabels: + return { + "dc": os.getenv("TRACING_TAGS_DC", ""), + "cluster": os.getenv("TRACING_TAGS_CLUSTER", ""), + "host": os.getenv("TRACING_TAGS_HOST", ""), + "os_process": os.getenv("TRACING_TAGS_PROCESS_NAME", executable), + "os_process_cmdline": " ".join(argv), + "docker_container": os.getenv("TRACING_TAGS_DOCKER_CONTAINER", ""), + "k8s_namespace": os.getenv("TRACING_TAGS_K8S_NAMESPACE", ""), + "k8s_kind": os.getenv("TRACING_TAGS_K8S_KIND", ""), + "k8s_pod": os.getenv("TRACING_TAGS_K8S_POD", ""), + "k8s_container": os.getenv("TRACING_TAGS_K8S_CONTAINER", ""), + "team": os.getenv("SRE_METRIC_LABEL_TEAM", ""), + "service": os.getenv("SRE_METRIC_LABEL_SERVICE", ""), + } + + +def start_http_metrics_server(port: int): + if ( + PROMETHEUS_MULTIPROC_DIR in os.environ + or PROMETHEUS_MULTIPROC_DIR.lower() in os.environ + ): + registry = CollectorRegistry() + MultiProcessCollector(registry) + else: + registry = REGISTRY + + start_http_server(port, registry=registry) diff --git a/app/metrics/constants.py b/app/metrics/constants.py new file mode 100755 index 0000000..10a0203 --- /dev/null +++ b/app/metrics/constants.py @@ -0,0 +1 @@ +PROMETHEUS_MULTIPROC_DIR = "PROMETHEUS_MULTIPROC_DIR" diff --git a/app/metrics/db/__init__.py b/app/metrics/db/__init__.py new file mode 100755 index 0000000..4652edd --- /dev/null +++ b/app/metrics/db/__init__.py @@ -0,0 +1,17 @@ +from .base import ( + SRE_DB_CONNECTIONS, + SRE_DB_QUERY_ERRORS, + SRE_DB_QUERY_TIME, + SRE_DB_QUERY_TOTAL, + SRE_DB_RESPONSE_RECORDS, + SRE_DB_RESPONSE_SIZE, +) + +__all__ = [ + "SRE_DB_CONNECTIONS", + "SRE_DB_QUERY_ERRORS", + "SRE_DB_QUERY_TIME", + "SRE_DB_QUERY_TOTAL", + "SRE_DB_RESPONSE_RECORDS", + "SRE_DB_RESPONSE_SIZE", +] diff --git a/app/metrics/db/base.py b/app/metrics/db/base.py new file mode 100755 index 0000000..c5b91f2 --- /dev/null +++ b/app/metrics/db/base.py @@ -0,0 +1,74 @@ +import typing + +from prometheus_client import Counter + +from app.metrics.common import ( + LocationLabels, + get_location_labels_from_env, + location_labels, +) + + +class ConstCommonLabels(LocationLabels): + db: str + db_host: str + db_port: str + + +common_labels = (*ConstCommonLabels.__annotations__, "db_query") + + +SRE_DB_CONNECTIONS = Counter( + "db_client_connections_total", + "Total amount of connections", + ("db", "db_host", "db_port", *location_labels), +) + +SRE_DB_QUERY_TOTAL = Counter("db_client_query_total", "Query counter", common_labels) + +SRE_DB_QUERY_TIME = Counter( + "db_client_query_time_total", + "Query execution time", + common_labels, +) + +SRE_DB_RESPONSE_SIZE = Counter( + "db_client_query_bytes_total", + "Bytes in the response", + common_labels, +) + +SRE_DB_RESPONSE_RECORDS = Counter( + "db_client_query_records_total", + "Amount of records in the response", + common_labels, +) + +SRE_DB_QUERY_ERRORS = Counter( + "db_client_query_errors_total", + "Total number of errors on each query", + common_labels, +) + + +def get_const_common_labels( + db: str, db_host: str, db_port: typing.Union[str, int] +) -> ConstCommonLabels: + loc_labels = get_location_labels_from_env() + return { + "dc": loc_labels["dc"], + "cluster": loc_labels["cluster"], + "host": loc_labels["host"], + "k8s_namespace": loc_labels["k8s_namespace"], + "k8s_kind": loc_labels["k8s_kind"], + "k8s_pod": loc_labels["k8s_pod"], + "k8s_container": loc_labels["k8s_container"], + "docker_container": loc_labels["docker_container"], + "os_process": loc_labels["os_process"], + "os_process_cmdline": loc_labels["os_process_cmdline"], + "team": loc_labels["team"], + "service": loc_labels["service"], + "db": db, + "db_host": db_host, + "db_port": str(db_port), + } diff --git a/app/metrics/db/sqlalchemy.py b/app/metrics/db/sqlalchemy.py new file mode 100755 index 0000000..d56319f --- /dev/null +++ b/app/metrics/db/sqlalchemy.py @@ -0,0 +1,270 @@ +import re +import timeit +import typing + +from prometheus_client import Counter, Gauge +from sqlalchemy import event +from sqlalchemy.engine import Compiled, CursorResult, Engine, ExceptionContext +from sqlalchemy.ext.asyncio import AsyncEngine +from sqlalchemy.future import Connection +from sqlalchemy.pool import QueuePool +from sqlalchemy.sql import ClauseElement + +from app.metrics.common import location_labels +from app.metrics.db.base import ( + SRE_DB_CONNECTIONS, + SRE_DB_QUERY_ERRORS, + SRE_DB_QUERY_TIME, + SRE_DB_QUERY_TOTAL, + ConstCommonLabels, + get_const_common_labels, +) + +EventClauseElement = typing.Union[ClauseElement, Compiled, str] +QueryLabelsGetter = typing.Callable[[EventClauseElement], typing.Dict[str, typing.Any]] +_DIGITS_REGEX = re.compile(r"\d+") + + +def add_event_listeners( + engine: typing.Union[Engine, AsyncEngine], + enable_pool_metrics: bool = False, +) -> None: + """Add all currently implemented event listeners to the given engine.""" + + const_labels = get_const_common_labels( + db=engine.url.database, + db_host=engine.url.host, + db_port=engine.url.port, + ) + sync_engine = engine if isinstance(engine, Engine) else engine.sync_engine + + event.listen(sync_engine, "connect", ConnectionsTotal(const_labels).on_connect) + + event.listen( + sync_engine, "before_execute", QueryTotal(const_labels).on_before_execute + ) + + query_time = QueryTime(const_labels) + event.listen(sync_engine, "before_execute", query_time.on_before_execute) + event.listen(sync_engine, "after_execute", query_time.on_after_execute) + event.listen(sync_engine, "handle_error", query_time.on_handle_error) + + event.listen( + sync_engine, "handle_error", QueryErrorsTotal(const_labels).on_handle_error + ) + + if enable_pool_metrics and isinstance(sync_engine.pool, QueuePool): + queue_pool_status = QueuePoolStatus( + const_labels=const_labels, pool=sync_engine.pool + ) + + event.listen(sync_engine.pool, "checkin", queue_pool_status.checkin) + event.listen(sync_engine.pool, "checkout", queue_pool_status.checkout) + + +class ConnectionsTotal: + """Total count of connecting events.""" + + def __init__( + self, const_labels: ConstCommonLabels, metric: Counter = SRE_DB_CONNECTIONS + ) -> None: + self.const_labels = const_labels + self.metric = metric + + def on_connect( + self, dbapi_connection: typing.Any, connection_record: typing.Any + ) -> None: + self.metric.labels(**self.const_labels).inc() + + +class QueuePoolStatus: + """ + Queue pool status. + + checked_in_metric: Total number of currently free connections in pool. + checked_out_metric: Total count of currently checked out connections. + overflow_metric: Total number of currently overflowed connections. + """ + + def __init__( + self, + const_labels: ConstCommonLabels, + pool: QueuePool, + checked_in_metric: typing.Optional[Gauge] = None, + checked_out_metric: typing.Optional[Gauge] = None, + overflow_metric: typing.Optional[Gauge] = None, + ) -> None: + self.pool = pool + self.const_labels = const_labels + + self.checked_in_metric = checked_in_metric or Gauge( + "db_client_free_connections_in_pool_total", + "Total number of currently free connections in pool.", + ("db", "db_host", "db_port", *location_labels), + ) + self.checked_out_metric = checked_out_metric or Gauge( + "db_client_connections_in_progress_total", + "Total number of currently active connections.", + ("db", "db_host", "db_port", *location_labels), + ) + self.overflow_metric = overflow_metric or Gauge( + "db_client_overflowed_connections_in_pool_total", + "Total number of currently overflowed connections.", + ("db", "db_host", "db_port", *location_labels), + ) + + def _status(self): + self.checked_in_metric.labels(**self.const_labels).set(self.pool.checkedin()) + self.checked_out_metric.labels(**self.const_labels).set(self.pool.checkedout()) + self.overflow_metric.labels(**self.const_labels).set(self.pool.overflow()) + + def checkout( + self, + dbapi_connection: typing.Any, + connection_record: typing.Any, + connection_proxy: typing.Any, + ) -> None: + self._status() + + def checkin( + self, dbapi_connection: typing.Any, connection_record: typing.Any + ) -> None: + self._status() + + +def default_query_labels_getter( + clauseelement: EventClauseElement, +) -> typing.Dict[str, typing.Any]: + return {"db_query": get_query_name(clauseelement)} + + +def get_query_name(clauseelement: EventClauseElement) -> str: + # XXX: How to work with other than `str` types of event clause element? + clauseelement = str(clauseelement) + # XXX: How to define a query name for `str`? + query_name = " ".join(clauseelement.split(maxsplit=3)[:3]) + # We want to replace all digits with NUM to avoid cardinality explosion. + # example of the query: "SAVEPOINT sa_savepoint_33" + return re.sub(_DIGITS_REGEX, "", query_name) + + +class QueryTotal: + def __init__( + self, + const_labels: ConstCommonLabels, + query_labels_getter: QueryLabelsGetter = default_query_labels_getter, + metric: Counter = SRE_DB_QUERY_TOTAL, + ) -> None: + self.const_labels = const_labels + self.query_labels_getter = query_labels_getter + self.metric = metric + + def on_before_execute( + self, + conn: Connection, + clauseelement: EventClauseElement, + multiparams: typing.List[typing.Dict[str, typing.Any]], + params: typing.Dict[str, typing.Any], + execution_options: typing.Dict[str, typing.Any], + ) -> None: + labels = {**self.const_labels, **self.get_event_labels(clauseelement)} + self.metric.labels(**labels).inc() + + def get_event_labels( + self, clauseelement: EventClauseElement + ) -> typing.Dict[str, typing.Any]: + return {**self.query_labels_getter(clauseelement)} + + +class QueryTime: + CONTEXT_KEY = "query_start_time" + + def __init__( + self, + const_labels: ConstCommonLabels, + query_labels_getter: QueryLabelsGetter = default_query_labels_getter, + metric: Counter = SRE_DB_QUERY_TIME, + ) -> None: + self.const_labels = const_labels + self.query_labels_getter = query_labels_getter + self.metric = metric + + def on_before_execute( + self, + conn: Connection, + clauseelement: EventClauseElement, + multiparams: typing.List[typing.Dict[str, typing.Any]], + params: typing.Dict[str, typing.Any], + execution_options: typing.Dict[str, typing.Any], + ) -> None: + conn.info.setdefault(self.CONTEXT_KEY, []).append(timeit.default_timer()) + + def on_after_execute( + self, + conn: Connection, + clauseelement: EventClauseElement, + multiparams: typing.List[typing.Dict[str, typing.Any]], + params: typing.Dict[str, typing.Any], + execution_options: typing.Dict[str, typing.Any], + result: CursorResult, + ) -> None: + labels = {**self.const_labels, **self.get_event_labels(clauseelement)} + total_sec = timeit.default_timer() - conn.info[self.CONTEXT_KEY].pop(-1) + self.metric.labels(**labels).inc(total_sec * 1000) + + def on_handle_error(self, exception_context: ExceptionContext) -> None: + connection = exception_context.connection + if connection and self.CONTEXT_KEY in connection.info: + labels = { + **self.const_labels, + **self.get_event_labels( + _get_clauseelement_from_exception_context(exception_context) + ), + } + total_sec = timeit.default_timer() - connection.info[self.CONTEXT_KEY].pop( + -1 + ) + self.metric.labels(**labels).inc(total_sec * 1000) + + def get_event_labels( + self, clauseelement: EventClauseElement + ) -> typing.Dict[str, typing.Any]: + return {**self.query_labels_getter(clauseelement)} + + +class QueryErrorsTotal: + def __init__( + self, + const_labels: ConstCommonLabels, + query_labels_getter: QueryLabelsGetter = default_query_labels_getter, + metric: Counter = SRE_DB_QUERY_ERRORS, + ) -> None: + self.const_labels = const_labels + self.query_labels_getter = query_labels_getter + self.metric = metric + + def on_handle_error(self, exception_context: ExceptionContext) -> None: + labels = { + **self.const_labels, + **self.get_event_labels( + _get_clauseelement_from_exception_context(exception_context) + ), + } + self.metric.labels(**labels).inc() + + def get_event_labels(self, statement: str) -> typing.Dict[str, typing.Any]: + return {**self.query_labels_getter(statement)} + + +# TODO CRYPTO-148: Implement ResponseSize, ResponseRecords + + +def _get_clauseelement_from_exception_context( + context: ExceptionContext, +) -> EventClauseElement: + exec_context = context.execution_context + if exec_context: + compiled = getattr(exec_context, "compiled", None) + if compiled: + return compiled + return context.statement or "" diff --git a/app/metrics/http_in.py b/app/metrics/http_in.py new file mode 100755 index 0000000..20a7aaf --- /dev/null +++ b/app/metrics/http_in.py @@ -0,0 +1,93 @@ +from prometheus_client import Counter, Gauge, Histogram + +from app.metrics.common import location_labels + +LATENCY_BUCKETS = ( + 50, + 100, + 250, + 500, + 750, + 1000, + 2500, + 5000, + 7500, + 10000, + 25000, + float("inf"), +) + +common_labels = ( + "http_in_host", + "http_in_ip", + "http_in_port", + "http_in_method", + "http_in_url", + "http_in_source_ip", + "http_in_source_port", + *location_labels, +) + + +class HttpIn: + _instance = None + + @classmethod + def get_instance(cls, *args, **kwargs): + if not cls._instance: + cls._instance = cls(*args, **kwargs) + return cls._instance + + def __init__(self, include_latency_histogram: bool = False): + self.SRE_SERVICE_UPTIME = Gauge( + "http_in_uptime", + "Seconds since the HTTP listener has started", + ("http_in_ip", "http_in_port", "http_in_tier", *location_labels), + multiprocess_mode="max", + ) + + self.SRE_REQUESTS_TOTAL = Counter( + "http_in_requests_total", "Total count of requests", common_labels + ) + + self.SRE_REQUEST_BYTES = Counter( + "http_in_request_bytes", "Total amount of request body size", common_labels + ) + + self.SRE_RESPONSES_TOTAL = Counter( + "http_in_responses_total", + "Total count of responses", + ("http_in_response_code", *common_labels), + ) + + self.SRE_RESPONSE_BYTES = Counter( + "http_in_response_bytes_total", + "Total amount of response body size", + ("http_in_response_code", *common_labels), + ) + + self.SRE_RESPONSE_TIME = Counter( + "http_in_response_time_total", + "Total amount of response time", + ("http_in_response_code", *common_labels), + ) + + if include_latency_histogram: + self.SRE_RESPONSE_TIME_HISTOGRAM = Histogram( + "http_in_response_time_histogram", + "Total amount of response time", + ("http_in_method", "http_in_url", *location_labels), + buckets=LATENCY_BUCKETS, + ) + + self.SRE_REQUEST_ERRORS = Counter( + "http_in_request_errors_total", + "Total amount of request errors", + ("http_in_request_error", *common_labels), + ) + + self.SRE_RESPONSE_ERRORS = Counter( + "http_in_response_errors_total", + "Total amount of response errors", + ("http_in_response_code", "http_in_response_error", *common_labels), + ) diff --git a/app/metrics/http_out.py b/app/metrics/http_out.py new file mode 100755 index 0000000..704c0f1 --- /dev/null +++ b/app/metrics/http_out.py @@ -0,0 +1,73 @@ +from prometheus_client import Counter, Gauge + +from app.metrics.common import location_labels + +common_labels = ( + "http_out_host", + "http_out_port", + "http_out_method", + "http_out_url", + *location_labels, +) + +SRE_DNS_TIME = Gauge("http_out_dns_time", "Time spent on DNS resolve", common_labels) + +SRE_CONNECT_TIME = Counter( + "http_out_connect_time_total", + "Time spent connecting to the remote endpoint", + common_labels, +) + +SRE_HANDSHAKE_TIME = Counter( + "http_out_handshake_time_total", + "Time that spends on handshake to the remote endpoint in a case of TLS ", + common_labels, +) + +SRE_REQUEST = Counter( + "http_out_requests_total", + "Total amount of outgoing requests on each HTTP connection", + common_labels, +) + +SRE_REQUEST_SIZE = Counter( + "http_out_request_bytes_total", + "Size of outgoing request on each HTTP connection", + common_labels, +) + +SRE_REQUEST_ERROR = Counter( + "http_out_request_errors_total", + "Amount of errors on outgoing request on each HTTP connection", + ("http_out_request_error", *common_labels), +) + +SRE_RESPONSE = Counter( + "http_out_responses_total", + "Amount of errors on outgoing request on each HTTP connection", + ("http_out_response_code", *common_labels), +) + +SRE_RESPONSE_SIZE = Counter( + "http_out_response_bytes_total", + "Content length or response size", + ("http_out_response_code", *common_labels), +) + +SRE_RESPONSE_ERROR = Counter( + "http_out_response_errors_total", + "Total amount of outgoing errors on each response", + ("http_out_response_code", "http_out_response_error", *common_labels), +) + +SRE_RESPONSE_FIRST_BYTE = Gauge( + "http_out_response_first_byte_time", + "Time spent on getting first byte from the remote endpoint", + ("http_out_response_code", *common_labels), +) + +SRE_RESPONSE_TIME = Counter( + "http_out_response_time_total", + "Total amount of outgoing errors on each response", + ("http_out_response_code", *common_labels), +) diff --git a/app/metrics/job.py b/app/metrics/job.py new file mode 100755 index 0000000..9942276 --- /dev/null +++ b/app/metrics/job.py @@ -0,0 +1,21 @@ +from prometheus_client import Counter + +from app.metrics.common import location_labels + +SRE_JOB_EXECUTIONS = Counter( + "job_executions_total", + "Total amount of executions", + ("job_name", *location_labels), +) + +SRE_JOB_EXECUTION_TIME = Counter( + "job_execution_time_total", + "Execution time", + ("job_name", *location_labels), +) + +SRE_JOB_ERRORS = Counter( + "job_errors_total", + "Amount of errors", + ("job_name", "job_error", *location_labels), +) diff --git a/app/metrics/server.py b/app/metrics/server.py new file mode 100755 index 0000000..06acf8c --- /dev/null +++ b/app/metrics/server.py @@ -0,0 +1,170 @@ +import os +import timeit +from typing import Any, Dict + +from prometheus_client import ( + CONTENT_TYPE_LATEST, + REGISTRY, + CollectorRegistry, + generate_latest, +) +from prometheus_client.multiprocess import MultiProcessCollector +from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint +from starlette.requests import Request +from starlette.responses import Response +from starlette.routing import Match +from starlette.types import ASGIApp + +from app.exceptions.api_errors import APIError +from app.metrics.common import get_location_labels_from_env +from app.metrics.constants import PROMETHEUS_MULTIPROC_DIR +from app.metrics.http_in import HttpIn + + +class ASGIMetricsMiddleware(BaseHTTPMiddleware): + def __init__( + self, + app: ASGIApp, + tier: int = 1, + include_latency_histogram=False, + record_source_ip=False, + record_source_port=False, + include_not_found_url_label=True, + ): + super().__init__(app) + self.include_latency_histogram = include_latency_histogram + self.http_in = HttpIn.get_instance(include_latency_histogram) + self.tier = tier + self.start_time = timeit.default_timer() + self.record_source_ip = record_source_ip + self.record_source_port = record_source_port + self.include_not_found_url_label = include_not_found_url_label + + async def dispatch( + self, request: Request, call_next: RequestResponseEndpoint + ) -> Response: + request_start_time = ( + timeit.default_timer() + ) # TODO depends on the order of the middleware + common_labels = self.get_common_labels(request) + self.observe_uptime(request) + self.observe_request(request, common_labels) + response_content_length = 0 + status_code = "" + error_message = "" + + try: + response = await call_next(request) + except Exception as e: + status_code = 500 + response_content_length = 0 + error_message = "Unhandled exception" + raise e from None + else: + status_code = response.status_code + response_content_length = int(response.headers.get("content-length", "0")) + # I was unable to find a satisfactory way to obtain a detailed error message + # falling back to the default message based on the status code + error_message = APIError.get_cls_by_code(status_code).default_message + finally: + latency = int((timeit.default_timer() - request_start_time) * 1000) + self.observe_response( + common_labels, + latency, + status_code, + response_content_length, + error_message, + ) + + return response + + def observe_response( + self, + labels: Dict[str, Any], + latency: int, + status_code: int, + content_length: int, + error_message: str, + ): + response_labels = { + **labels, + "http_in_response_code": status_code, + } + + if status_code >= 400: + self.http_in.SRE_RESPONSE_ERRORS.labels( + **{**response_labels, "http_in_response_error": error_message} + ).inc() + + self.http_in.SRE_RESPONSE_BYTES.labels(**response_labels).inc(content_length) + self.http_in.SRE_RESPONSE_TIME.labels(**response_labels).inc(latency) + if self.include_latency_histogram: + self.http_in.SRE_RESPONSE_TIME_HISTOGRAM.labels( + http_in_method=response_labels.get("http_in_method", ""), + http_in_url=response_labels.get("http_in_url", ""), + **get_location_labels_from_env(), + ).observe(latency) + self.http_in.SRE_RESPONSES_TOTAL.labels(**response_labels).inc() + + def observe_request(self, request: Request, labels: Dict[str, Any]): + content_length = int(request.headers.get("content-length", "0")) + self.http_in.SRE_REQUESTS_TOTAL.labels(**labels).inc() + self.http_in.SRE_REQUEST_BYTES.labels(**labels).inc(content_length) + + def observe_uptime(self, request: Request): + http_in_ip, http_in_port = request.get("server") + uptime = timeit.default_timer() - self.start_time + self.http_in.SRE_SERVICE_UPTIME.labels( + **{ + **self.get_location_labels(), + "http_in_ip": http_in_ip, + "http_in_port": http_in_port, + "http_in_tier": self.tier, + } + ).set(uptime) + + def get_location_labels(self) -> Dict[str, str]: + return get_location_labels_from_env() + + def get_common_labels(self, request: Request) -> Dict[str, Any]: + path_template = self.get_path_template(request) + http_in_ip, http_in_port = request.get("server") + client_host = request.client.host + client_port = request.client.port + + return { + **self.get_location_labels(), + "http_in_host": request.base_url.hostname, + "http_in_ip": http_in_ip, + "http_in_port": http_in_port, + "http_in_method": request.method, + "http_in_url": path_template, + "http_in_source_ip": client_host if self.record_source_ip else "", + "http_in_source_port": client_port if self.record_source_port else "", + } + + def get_path_template(self, request: Request) -> str: + for route in request.app.routes: + match, child_scope = route.matches(request.scope) + if match in (Match.FULL, Match.PARTIAL): + return route.path + + if self.include_not_found_url_label: + return request.url.path + + return "-" + + +async def metrics_handler(request: Request): + if ( + PROMETHEUS_MULTIPROC_DIR in os.environ + or PROMETHEUS_MULTIPROC_DIR.lower() in os.environ + ): + registry = CollectorRegistry() + MultiProcessCollector(registry) + else: + registry = REGISTRY + + return Response( + generate_latest(registry), headers={"Content-Type": CONTENT_TYPE_LATEST} + ) diff --git a/app/routers/__init__.py b/app/routers/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/routers/gitlab.py b/app/routers/gitlab.py new file mode 100755 index 0000000..aafaec3 --- /dev/null +++ b/app/routers/gitlab.py @@ -0,0 +1,73 @@ +import logging +from typing import Optional + +import sentry_sdk +from fastapi import APIRouter, Depends +from pydantic import BaseModel + +from app.exceptions.schemas import ValidationError +from app.secbot.inputs.gitlab.dependencies import ( + get_gitlab_webhook_token_header, + gitlab_event, + webhook_model, +) +from app.secbot.inputs.gitlab.schemas import AnyGitlabModel, GitlabEvent + +logger = logging.getLogger(__name__) +router = APIRouter( + prefix="/gitlab", + tags=["gitlab"], + dependencies=[Depends(get_gitlab_webhook_token_header)], +) + + +class WebhookReplyModel(BaseModel): + status: str = "ok" + + +@router.post( + "/webhook", + response_model=WebhookReplyModel, + response_description=f"""We support only {', '.join(GitlabEvent)} events. + For the rest any events we will return 200 OK and do nothing. + """, + responses={ + 403: { + "description": "Gitlab webhook secret token missing or invalid", + "model": ValidationError, + "content": { + "application/json": { + "example": { + "code": "FORBIDDEN", + "message": "X-Gitlab-Token header is invalid", + "details": None, + } + }, + }, + }, + }, +) +async def post_webhook( + event: Optional[GitlabEvent] = Depends(gitlab_event), + data: Optional[AnyGitlabModel] = Depends(webhook_model), +): + if not event: + logger.info("Unsupported event", extra={"event": event}) + return WebhookReplyModel() + + if not data: + logger.warning("Unsupported event data", extra={"data": data}) + with sentry_sdk.push_scope() as scope: + scope.set_extra("event", event) + scope.set_extra("data", data) + sentry_sdk.capture_message("Unsupported event data") + return WebhookReplyModel() + + logger.info( + "Received gitlab webhook event", + extra={"event": event, "data": data.raw}, + ) + from app.main import security_bot + + await security_bot.run("gitlab", data=data, event=event) + return WebhookReplyModel() diff --git a/app/routers/healthcheck.py b/app/routers/healthcheck.py new file mode 100755 index 0000000..4e2fd96 --- /dev/null +++ b/app/routers/healthcheck.py @@ -0,0 +1,14 @@ +from fastapi import APIRouter +from pydantic import BaseModel + +router = APIRouter(tags=["common"]) + + +class PingReplyModel(BaseModel): + ping: str = "pong" + + +@router.get("/ping", response_model=PingReplyModel) +def get_ping(): + """Healthcheck for L7 load balancers.""" + return PingReplyModel() diff --git a/app/routers/metrics.py b/app/routers/metrics.py new file mode 100755 index 0000000..9ef5ba1 --- /dev/null +++ b/app/routers/metrics.py @@ -0,0 +1,20 @@ +from fastapi import APIRouter +from prometheus_client import REGISTRY, generate_latest +from starlette.responses import PlainTextResponse + +router = APIRouter(tags=["common"]) + + +@router.get( + "/metrics", + response_class=PlainTextResponse, + description="Application metrics in Prometheus format.", + responses={ + 200: { + "description": "Metrics", + "content": {"text/plain": {"example": ""}}, + } + }, +) +def get_metrics(): + return generate_latest(REGISTRY) diff --git a/app/routers/security.py b/app/routers/security.py new file mode 100755 index 0000000..7a808f2 --- /dev/null +++ b/app/routers/security.py @@ -0,0 +1,56 @@ +import logging + +from fastapi import APIRouter +from pydantic import BaseModel + +from app.secbot.inputs.gitlab.schemas import GitlabWebhookSecurityID +from app.secbot.schemas import SecurityCheckStatus + +logger = logging.getLogger(__name__) +router = APIRouter(prefix="/security", tags=["security"]) + + +class SecurityCheckResponse(BaseModel): + status: SecurityCheckStatus + + +# TODO(ivan.zhirov): add tests +@router.get( + "/gitlab/check/{security_check_id}", + response_model=SecurityCheckResponse, + responses={ + 200: { + "content": { + "application/json": { + "examples": { + "Check happens before check has been created.": { + "value": {"status": "not_started"}, + }, + "Check happens before scans has been created.": { + "value": {"status": "not_started"}, + }, + "Technical problem with the scan": { + "value": {"status": "error"}, + }, + "Security check in progress": { + "value": {"status": "in_progress"}, + }, + "Security check has been failed": { + "value": {"status": "fail"}, + }, + "Security check has been successful": { + "value": {"status": "success"}, + }, + } + } + } + } + }, +) +async def get_security_check( + security_check_id: GitlabWebhookSecurityID, +) -> SecurityCheckResponse: + from app.main import security_bot + + status = await security_bot.fetch_check_result("gitlab", security_check_id) + return SecurityCheckResponse(status=status) diff --git a/app/secbot/__init__.py b/app/secbot/__init__.py new file mode 100755 index 0000000..9a2add7 --- /dev/null +++ b/app/secbot/__init__.py @@ -0,0 +1,93 @@ +import importlib +import inspect +import os +import pkgutil +from typing import Type + +from celery import Celery + +from .inputs import SecbotInput +from .logger import logger +from .schemas import SecurityCheckStatus + + +class SecurityBot: + """ + Main class for the SecurityBot application. Manages inputs for security checks, + runs these checks, and fetches check results. + + Attributes: + celery_app: Celery application instance for managing asynchronous tasks. + _registered_inputs: Dictionary of registered inputs (security checks). + """ + + def __init__(self, celery_app: Celery): + self.celery_app = celery_app + self._registered_inputs = {} # Contains the registered inputs + self.autodiscover_inputs() + + def autodiscover_inputs(self): + """ + Automatically discover all available inputs (security checks) + from the inputs module, and register them to the bot. + """ + base_package = "app.secbot.inputs" + base_path = os.path.dirname(__import__(base_package, fromlist=[""]).__file__) + + # Iterate over all modules in the base package + for _, package_name, _ in pkgutil.iter_modules([base_path]): + full_package_name = f"{base_package}.{package_name}" + try: + module = importlib.import_module(full_package_name) + except ImportError as e: + logger.warning( + f"Could not import {full_package_name}. Error: {str(e)}" + ) + continue + + # Register all classes that are a subclass of SecbotInput (excluding SecbotInput itself) + for name, cls in inspect.getmembers(module, inspect.isclass): + if issubclass(cls, SecbotInput) and cls != SecbotInput: + self.register_input(package_name, cls) + + def register_input(self, config_name: str, input_cls: Type[SecbotInput]): + """ + Register a new input (security check) to the bot. + + Args: + config_name: The name of the configuration for the input. + input_cls: The class representing the input. + """ + self._registered_inputs[config_name] = input_cls( + config_name=config_name, + celery_app=self.celery_app, + ) + + async def run(self, input_name: str, *args, **kwargs): + """ + Run a registered input (security check). + + Args: + input_name: The name of the input to run. + args, kwargs (optional): Arguments to pass to the input's run method. + """ + registered_input = self._registered_inputs[input_name] + await registered_input.run(*args, **kwargs) + + async def fetch_check_result( + self, + input_name, + *args, + **kwargs, + ) -> SecurityCheckStatus: + """ + Fetch the result of a security check. + + Args: + input_name: The name of the input whose result to fetch. + args, kwargs (optional): Arguments to pass to the input's fetch_result method. + Returns: + The status of the security check. + """ + registered_input = self._registered_inputs[input_name] + return await registered_input.fetch_status(*args, **kwargs) diff --git a/app/secbot/alembic.ini b/app/secbot/alembic.ini new file mode 100755 index 0000000..d099c3d --- /dev/null +++ b/app/secbot/alembic.ini @@ -0,0 +1,103 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +script_location = app/secbot/db/alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python-dateutil library that can be +# installed by adding `alembic[tz]` to the pip requirements +# string value is passed to dateutil.tz.gettz() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the +# "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to app/alembic/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:app/alembic/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 +sqlalchemy.url = + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/app/secbot/config.py b/app/secbot/config.py new file mode 100755 index 0000000..595ef5b --- /dev/null +++ b/app/secbot/config.py @@ -0,0 +1,198 @@ +from __future__ import annotations + +import os +import pathlib +import re +from collections import defaultdict +from typing import Any, Dict, List, Optional + +import yaml +from pydantic import BaseModel + +from app.secbot.exceptions import SecbotConfigError, SecbotConfigMissingEnv + +ConfigInputName = str + + +# Represents a configuration component in the Secbot workflow. +class SecbotConfigComponent(BaseModel): + name: str + handler_name: str + config: Optional[Dict[str, Any]] = None + env: Optional[Dict[str, Any]] = None + + +# Represents a job in the Secbot workflow. +class WorkflowJob(BaseModel): + name: str + input_name: ConfigInputName + rules: Optional[Dict[str, str]] = None + scans: List[SecbotConfigComponent] + outputs: List[SecbotConfigComponent] + notifications: Optional[List[SecbotConfigComponent]] = None + + +def get_jsonpath_value(event_raw: dict, path: str): + """Fetches a value from a dictionary by JSONPath. + + Args: + event_raw (dict): Dictionary to fetch value from. + path (str): JSONPath specifying value location. + Returns: + The value specified by the JSONPath. + """ + try: + key, rest_keys = path.split(".", 1) + value = event_raw[key] + if isinstance(value, dict): + return get_jsonpath_value(value, rest_keys) + except ValueError: + key = path + return event_raw[key] + + +def is_job_valid_for_rules(job: WorkflowJob, data: dict) -> bool: + """Checks if the given job configuration matches the data. + + Args: + job (WorkflowJob): Job to check. + data (dict): Data to match against. + Returns: + bool: True if job's rules match the data. + """ + if not (rules := job.rules or {}): + return True + + for jsonpath, rule_regex in rules.items(): + value = get_jsonpath_value(data, jsonpath) + if re.fullmatch(rule_regex, value) is None: + return False + return True + + +def config_parser(obj: dict) -> Dict[ConfigInputName, List[WorkflowJob]]: + """Parses the configuration file (version 1.0). + + Args: + obj (dict): Dictionary representing the configuration file. + Returns: + dict: Maps from input names to lists of jobs. + """ + components = {} + for component_name, component_data in obj["components"].items(): + parsed_env = {} + for key, value in component_data.get("env", {}).items(): + try: + parsed_env[key] = os.getenv(value) + except AttributeError: + raise SecbotConfigMissingEnv( + f"Failed to parse env variable {value} " + f"for component {component_name}" + ) + components[component_name] = SecbotConfigComponent( + handler_name=component_data["handler_name"], + name=component_name, + config=component_data.get("config"), + env=parsed_env or None, + ) + + if not components: + raise SecbotConfigError("No components found in config") + + jobs = defaultdict(list) + for job in obj["jobs"]: + rules = job["rules"] + + # Combine names of components with component models + job_scans = [components[name] for name in job["scans"]] + job_outputs = [components[name] for name in job["outputs"]] + job_notifications = [components[name] for name in job["notifications"]] + + for input_name in set(rules.keys()): + jobs[input_name].append( + WorkflowJob( + name=job["name"], + input_name=input_name, + rules=rules[input_name], + scans=job_scans, + outputs=job_outputs, + notifications=job_notifications, + ) + ) + if not jobs: + raise SecbotConfigError("No jobs found in config") + return jobs + + +class SecbotConfig: + """Represents the Secbot configuration file. + + Methods: + - from_yml_file: Load configuration from a YAML file. + - matching_workflow_job: Returns matching jobs. + """ + + # A dictionary that maps configuration version numbers to their corresponding + # parser functions. The CONFIG_VERSION_PARSER is only responsible for + # validating the configuration file itself. The security bot (secbot) will + # handle the validation of the handlers separately. + # + # TODO(ivan.zhirov): Update the implementation to support versioning semantics, + # including tilde and caret ranges. + VERSIONS_PARSER = { + "1.0": config_parser, + } + + @classmethod + def from_yml_file(cls, config_path: str) -> SecbotConfig: + """Load Secbot configuration from a YAML file. + + Args: + config_path (str): Path to the YAML file. + Returns: + SecbotConfig: Loaded Secbot configuration. + """ + base_path = pathlib.Path(os.path.dirname(__file__)) + with open(base_path / config_path) as f: + config_obj = yaml.safe_load(f.read()) + return cls(config_obj) + + def __init__(self, config_obj: dict): + try: + version = config_obj["version"] + except KeyError: + raise SecbotConfigError("Config version is not specified") + try: + parser = self.VERSIONS_PARSER[str(version)] + except KeyError: + raise SecbotConfigError(f"Unsupported config version: {version}") + + self.jobs: Dict[ConfigInputName, List[WorkflowJob]] = parser(config_obj) + + def matching_workflow_job( + self, + input_name: ConfigInputName, + data: Dict[str, Any], + ) -> Optional[WorkflowJob]: + """Returns the job that matches a given input name and data. + Currently, only one job per data is supported. + + Args: + input_name (ConfigInputName): Input name to match. + data (Dict[str, Any]): Data to match against. + Returns: + Optional[WorkflowJob]: Matching job, if exists; None otherwise. + """ + ret = [ + job for job in self.jobs[input_name] if is_job_valid_for_rules(job, data) + ] + # TODO(ivan.zhirov): Currently, we only support one job per data. + # Consider changing this in the future. + if len(ret) > 1: + raise SecbotConfigError( + f"Multiple jobs found for input {input_name} and data {data}" + ) + return next(iter(ret), None) + + +config = SecbotConfig.from_yml_file("../config.yml") diff --git a/app/secbot/db/__init__.py b/app/secbot/db/__init__.py new file mode 100755 index 0000000..5aa6af4 --- /dev/null +++ b/app/secbot/db/__init__.py @@ -0,0 +1,49 @@ +from sqlalchemy import Column, DateTime, event, func +from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine +from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.orm import sessionmaker +from sqlalchemy.pool import AsyncAdaptedQueuePool + +from app.metrics.db.base import get_const_common_labels +from app.metrics.db.sqlalchemy import ConnectionsTotal, add_event_listeners +from app.secbot.settings import settings + +engine = create_async_engine( + settings.postgres_dsn, + poolclass=AsyncAdaptedQueuePool, + pool_pre_ping=True, + pool_size=5, + pool_recycle=5 * 60, # 5 minutes + max_overflow=5, + pool_timeout=10, + connect_args={"server_settings": {"jit": "off"}}, + echo=False, +) + +# Setup metrics +add_event_listeners(engine) +const_labels = get_const_common_labels( + db=engine.url.database, + db_host=engine.url.host, + db_port=engine.url.port, +) +event.listen(engine.sync_engine, "connect", ConnectionsTotal(const_labels).on_connect) + +# Create session factory +db_session = sessionmaker( + autocommit=False, + autoflush=False, + bind=engine, + expire_on_commit=False, + class_=AsyncSession, +) + + +class BaseModel: + """General model of all models in the project""" + + created_at = Column(DateTime, default=func.now()) + updated_at = Column(DateTime, default=func.now(), onupdate=func.now()) + + +Base = declarative_base(cls=BaseModel) diff --git a/app/secbot/db/alembic/__init__.py b/app/secbot/db/alembic/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/secbot/db/alembic/env.py b/app/secbot/db/alembic/env.py new file mode 100755 index 0000000..0824bfa --- /dev/null +++ b/app/secbot/db/alembic/env.py @@ -0,0 +1,83 @@ +import asyncio +import os +from logging.config import fileConfig + +from alembic import context +from sqlalchemy import engine_from_config, pool +from sqlalchemy.ext.asyncio import AsyncEngine + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# For 'autogenerate' +from app.secbot.db.models import Base + +target_metadata = Base.metadata + +config.set_main_option("sqlalchemy.url", os.environ["SECBOT_POSTGRES_DSN"]) + + +def run_migrations_offline(): + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def do_run_migrations(connection): + context.configure( + connection=connection, + target_metadata=target_metadata, + ) + + with context.begin_transaction(): + context.run_migrations() + + +async def run_migrations_online(): + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + connectable = AsyncEngine( + engine_from_config( + config.get_section(config.config_ini_section), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + future=True, + ) + ) + + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + +if context.is_offline_mode(): + run_migrations_offline() +else: + asyncio.run(run_migrations_online()) diff --git a/app/secbot/db/alembic/script.py.mako b/app/secbot/db/alembic/script.py.mako new file mode 100755 index 0000000..55df286 --- /dev/null +++ b/app/secbot/db/alembic/script.py.mako @@ -0,0 +1,24 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision = ${repr(up_revision)} +down_revision = ${repr(down_revision)} +branch_labels = ${repr(branch_labels)} +depends_on = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/app/secbot/db/alembic/versions/3611bb3d9dd2_initial.py b/app/secbot/db/alembic/versions/3611bb3d9dd2_initial.py new file mode 100755 index 0000000..2fb45d4 --- /dev/null +++ b/app/secbot/db/alembic/versions/3611bb3d9dd2_initial.py @@ -0,0 +1,90 @@ +"""initial + +Revision ID: 3611bb3d9dd2 +Revises: +Create Date: 2023-05-31 12:53:57.376066 + +""" +import sqlalchemy as sa +from alembic import op +from sqlalchemy.dialects import postgresql + +# revision identifiers, used by Alembic. +revision = "3611bb3d9dd2" +down_revision = None +branch_labels = None +depends_on = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table( + "repository_security_check", + sa.Column("created_at", sa.DateTime(), nullable=True), + sa.Column("updated_at", sa.DateTime(), nullable=True), + sa.Column("id", sa.Integer(), autoincrement=True, nullable=False), + sa.Column("external_id", sa.String(), nullable=False), + sa.Column( + "event_type", + sa.Enum("PUSH", "TAG_PUSH", "MERGE_REQUEST", name="gitlabevent"), + nullable=False, + ), + sa.Column( + "event_json", postgresql.JSON(astext_type=sa.Text()), nullable=False + ), + sa.Column("commit_hash", sa.String(), nullable=False), + sa.Column("branch", sa.String(), nullable=False), + sa.Column("project_name", sa.String(), nullable=False), + sa.Column("path", sa.String(), nullable=False), + sa.Column("prefix", sa.String(), nullable=False), + sa.PrimaryKeyConstraint("id"), + sa.UniqueConstraint("external_id"), + ) + op.create_table( + "repository_security_scan", + sa.Column("created_at", sa.DateTime(), nullable=True), + sa.Column("updated_at", sa.DateTime(), nullable=True), + sa.Column("check_id", sa.Integer(), nullable=False), + sa.Column("id", sa.Integer(), autoincrement=True, nullable=False), + sa.Column("started_at", sa.DateTime(), nullable=True), + sa.Column("finished_at", sa.DateTime(), nullable=True), + sa.Column( + "status", + sa.Enum("NEW", "IN_PROGRESS", "SKIP", "ERROR", "DONE", name="scanstatus"), + nullable=False, + ), + sa.Column("response", postgresql.JSON(astext_type=sa.Text()), nullable=True), + sa.Column("scan_name", sa.String(), nullable=False), + sa.Column( + "outputs_test_id", postgresql.JSON(astext_type=sa.Text()), nullable=True + ), + sa.ForeignKeyConstraint( + ["check_id"], + ["repository_security_check.id"], + ), + sa.PrimaryKeyConstraint("id"), + ) + op.create_table( + "slack_notifications", + sa.Column("created_at", sa.DateTime(), nullable=True), + sa.Column("updated_at", sa.DateTime(), nullable=True), + sa.Column("id", sa.Integer(), autoincrement=True, nullable=False), + sa.Column("channel", sa.String(), nullable=False), + sa.Column("is_sent", sa.Boolean(), nullable=True), + sa.Column("payload", postgresql.JSON(astext_type=sa.Text()), nullable=False), + sa.Column("scan_id", sa.Integer(), nullable=False), + sa.ForeignKeyConstraint( + ["scan_id"], + ["repository_security_scan.id"], + ), + sa.PrimaryKeyConstraint("id"), + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table("slack_notifications") + op.drop_table("repository_security_scan") + op.drop_table("repository_security_check") + # ### end Alembic commands ### diff --git a/app/secbot/db/alembic/versions/__init__.py b/app/secbot/db/alembic/versions/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/secbot/db/models.py b/app/secbot/db/models.py new file mode 100755 index 0000000..b233248 --- /dev/null +++ b/app/secbot/db/models.py @@ -0,0 +1,2 @@ +from app.secbot.db import Base # noqa: F401 +from app.secbot.inputs.gitlab.models import * # noqa: F401,F403 diff --git a/app/secbot/exceptions.py b/app/secbot/exceptions.py new file mode 100755 index 0000000..0dfb402 --- /dev/null +++ b/app/secbot/exceptions.py @@ -0,0 +1,49 @@ +from __future__ import annotations + +import pprint + + +class SecbotException(Exception): + """Base gitlab exception class.""" + + +class BaseGitlabWorkflowException(SecbotException): + """Base gitlab exception with scan id info.""" + + +class ScanCheckFailed(SecbotException): + """Raises when we try to check scan status, and it's failed.""" + + +class ScanCantBeScanned(SecbotException): + """Raises when we try to scan a scan that already in progress.""" + + +class ScanExecutionSkipped(SecbotException): + """Raises when we want to make a scan skippable. + + It might happen when worker services can't proceed security check, + and we don't want to set the scan status to ERROR. + """ + + +class SecbotInputError(SecbotException): + """Base exception for all input exceptions.""" + + +class SecbotConfigError(SecbotException): + """This exception is raised when the configuration is invalid. + + It accumulates all possible errors that occur during the parsing of job + configurations and presents them all at once. + """ + + def __init__(self, errors): + self.errors = errors + + def __str__(self): + return pprint.pformat(self.errors) + + +class SecbotConfigMissingEnv(SecbotConfigError): + """This exception is raised when the configuration is missing an environment""" diff --git a/app/secbot/handlers.py b/app/secbot/handlers.py new file mode 100755 index 0000000..22b9b43 --- /dev/null +++ b/app/secbot/handlers.py @@ -0,0 +1,158 @@ +import abc +import asyncio +import functools +from typing import List, Optional, Type + +from celery import Celery +from pydantic import BaseModel + +from app.secbot import utils +from app.secbot.config import SecbotConfigComponent + + +def pydantic_celery_converter(func): + """Decorator for asynchronous functions that use Pydantic models in their inputs or outputs. + Serializes Pydantic models before the function is called and deserializes + them after the function returns. + + Args: + func: The asynchronous function to decorate. + Returns: + The decorated function. + """ + + @functools.wraps(func) + async def wrapper(*args, **kwargs): + ret = await func(*utils.serializer(args), **utils.serializer(kwargs)) + return utils.deserializer(ret) + + return wrapper + + +class SecbotHandler(abc.ABC): + """Abstract base class for SecbotHandler. + It provides a unified interface for creating handlers + for Secbot's various components (scans, outputs, notifications). + + Attributes: + config_model: Optional Pydantic model for the handler's configuration. + env_model: Optional Pydantic model for the handler's environment. + celery_app: Celery application instance for managing asynchronous tasks. + config_name: The name of the configuration for the handler. + task: The Celery task corresponding to the handler. + """ + + config_model: Optional[Type[BaseModel]] = None + env_model: Optional[Type[BaseModel]] = None + + def __init__(self, celery_app: Celery, config_name: str): + self.celery_app = celery_app + self.config_name = config_name + + def async_celery_task(*args, **kwargs): + """Wrapper function that calls the handler's `run` method + in an asyncio event loop. + + This function is used as the Celery task for this handler. + """ + loop = asyncio.get_event_loop() + return loop.run_until_complete( + pydantic_celery_converter(self.run)(*args, **kwargs) + ) + + def async_error_handler(task, exc, task_id, args, kwargs, einfo): + """ + Error handler that calls the handler's `on_failure` method in + an asyncio event loop in case of task failure. + + This function is set as the `on_failure` callback for the Celery task. + """ + loop = asyncio.get_event_loop() + loop.run_until_complete( + pydantic_celery_converter(self.on_failure)( + *args, + exception=exc, + **kwargs, + ) + ) + + generate_task_name = f"secbot.handler.{self.config_name}" + self.task = self.celery_app.task( + name=generate_task_name, + on_failure=async_error_handler, + )(async_celery_task) + + async def on_failure(self, *args, **kwargs): + """Async handler for task failure. + + Should be implemented in the subclasses as needed. + + Args: + args: Positional arguments passed to the task that failed. + kwargs: Keyword arguments passed to the task that failed. + """ + + @abc.abstractmethod + async def run(self, *args, **kwargs): + """Abstract method representing the main logic of the handler. + + Args: + args: Positional arguments passed to the handler. + kwargs: Keyword arguments passed to the handler. + + Raises: + NotImplementedError: This method needs to be implemented in each subclass. + """ + raise NotImplementedError + + +class SecbotScanHandler(SecbotHandler, abc.ABC): + """Abstract base class for SecbotScanHandler. + It inherits from SecbotHandler and provides a unified interface + for creating scan handlers. + + Scan handlers are responsible for performing security scans. + """ + + +class SecbotOutputHandler(SecbotHandler, abc.ABC): + """Abstract base class for SecbotOutputHandler. It inherits from SecbotHandler + and provides a unified interface for creating output handlers. + + Output handlers are responsible for processing the results of the scans + and outputting them to the specified destination. + """ + + @abc.abstractmethod + async def fetch_status( + self, + *args, + eligible_scans: List[SecbotConfigComponent], + **kwargs, + ) -> bool: + """Abstract method to retrieve the status of the security check. + Implemented in subclasses to fetch the status based on the specifics + of the output (e.g., retrieving from a specific database, or API). + + Args: + args: Positional arguments passed to the method. + eligible_scans: List of eligible scans for the security check. + kwargs: Keyword arguments passed to the method. + + Returns: + bool: The status of the security check. + + Raises: + NotImplementedError: This method needs to be implemented in each subclass. + """ + raise NotImplementedError + + +class SecbotNotificationHandler(SecbotHandler, abc.ABC): + """Abstract base class for SecbotNotificationHandler. + It inherits from SecbotHandler and provides a unified interface + for creating notification handlers. + + Notification handlers are responsible for sending notifications based + on the results of the security checks. + """ diff --git a/app/secbot/inputs/__init__.py b/app/secbot/inputs/__init__.py new file mode 100755 index 0000000..da7066b --- /dev/null +++ b/app/secbot/inputs/__init__.py @@ -0,0 +1,192 @@ +import abc +import importlib +import inspect +import os +import pkgutil +from typing import Iterator, List, Type, Union + +from celery import Celery +from celery.canvas import Signature, chain, group + +from app.secbot import utils +from app.secbot.config import SecbotConfigComponent, WorkflowJob +from app.secbot.exceptions import SecbotInputError +from app.secbot.handlers import ( + SecbotHandler, + SecbotNotificationHandler, + SecbotOutputHandler, + SecbotScanHandler, +) +from app.secbot.logger import logger +from app.secbot.schemas import ScanStatus, SecurityCheckStatus + + +class SecbotInput(abc.ABC): + """ + Abstract base class for SecbotInput. It handles the discovery and registration + of various handlers (scans, outputs, notifications) for each input. + + Attributes: + config_name: The name of the configuration for the input. + celery_app: Celery application instance for managing asynchronous tasks. + scans: Dictionary of registered scan handlers. + outputs: Dictionary of registered output handlers. + notifications: Dictionary of registered notification handlers. + """ + + def __init__(self, config_name: str, celery_app: Celery): + self.config_name = config_name + self.celery_app = celery_app + self.scans = {} + self.outputs = {} + self.notifications = {} + + self.autodiscover() + + def autodiscover(self): + """ + Automatically discover all available handlers (scans, outputs, notifications) + from the handlers module associated with this input, and register them. + """ + try: + base_package = f"app.secbot.inputs.{self.config_name}.handlers" + base_path = os.path.dirname( + __import__(base_package, fromlist=[""]).__file__ + ) + except ModuleNotFoundError: + logger.warning(f"Could not find handlers for {self.config_name}") + return + + handlers_cls = [ + SecbotScanHandler, + SecbotOutputHandler, + SecbotNotificationHandler, + ] + for _, package_name, _ in pkgutil.iter_modules([base_path]): + full_package_name = f"{base_package}.{package_name}" + try: + module = importlib.import_module(full_package_name) + except ImportError as e: + logger.warning( + f"Could not import {full_package_name}. Error: {str(e)}" + ) + continue + for name, cls in inspect.getmembers(module, inspect.isclass): + if issubclass(cls, tuple(handlers_cls)) and cls not in handlers_cls: + self.register_handler(package_name, cls) + + def register_handler( + self, + handler_name: str, + handler: Union[ + Type[SecbotScanHandler], + Type[SecbotOutputHandler], + Type[SecbotNotificationHandler], + ], + ): + """Register a new handler (scan, output, or notification) to the input. + + Args: + handler_name: The name of the handler to register. + handler: The class representing the handler. + """ + if issubclass(handler, SecbotScanHandler): + components_group = self.scans + elif issubclass(handler, SecbotOutputHandler): + components_group = self.outputs + elif issubclass(handler, SecbotNotificationHandler): + components_group = self.notifications + else: + raise SecbotInputError(f"Handler {handler} is not a valid Secbot handler") + + components_group[handler_name] = handler( + config_name=handler_name, + celery_app=self.celery_app, + ) + + async def run( + self, + *args, + job: WorkflowJob, + **kwargs, + ): + """Run a secbot workflow by executing a series of consecutive steps. + + The job configuration contains all necessary information + about the graph of dependencies. + The scan function serves as the entry point for each path in the graph, + and its results are sent to all registered outputs as configured by the job. + + Args: + job: The WorkflowJob instance that specifies the workflow to be run. + args: Positional arguments to be passed to the scan handler. + kwargs: Keyword arguments to be passed to the scan handler. + """ + + def build_component_tasks( + components_group: str, + *component_args, + **component_kwargs, + ) -> Iterator[Signature]: + + for item in getattr(job, components_group): + item: SecbotConfigComponent + component: SecbotHandler = getattr(self, components_group)[ + item.handler_name + ] + component_kwargs["component_name"] = item.name + if component.env_model and item.env: + env_dict = item.env or {} + component_kwargs["env"] = component.env_model(**env_dict) + if component.config_model: + config_dict = item.config or {} + component_kwargs["config"] = component.config_model(**config_dict) + + # Deserialize all pydantic models in the arguments and kwargs converts it + # to json serializable objects + prepared_args = utils.deserializer(component_args) + prepared_kwargs = utils.deserializer(component_kwargs) + + yield component.task.s(*prepared_args, **prepared_kwargs) + + scan_tasks = list(build_component_tasks("scans", *args, **kwargs)) + output_tasks = list(build_component_tasks("outputs")) + notification_tasks = list(build_component_tasks("notifications")) + + for scan_task in scan_tasks: + for output_task in output_tasks: + chain( + scan_task, + output_task, + group(notification_tasks), + ).delay() + + async def fetch_status( + self, + outputs: List[SecbotConfigComponent], + eligible_scans: List[SecbotConfigComponent], + **kwargs, + ) -> SecurityCheckStatus: + """ + Fetch the status of the security checks associated with the given outputs. + + Args: + eligible_scans: The scans that are eligible for the check. + outputs: The outputs for which to fetch the status. + kwargs: Additional keyword arguments to pass to the output handler. + Returns: + The status of the security checks (either SUCCESS or FAIL). + """ + results: List[ScanStatus] = [] + for output in outputs: + handler = self.outputs[output.handler_name] + if handler.env_model: + # Inject env model into kwargs like in output decorator + kwargs["env"] = handler.env_model(**output.env) + status = await handler.fetch_status( + eligible_scans=eligible_scans, **kwargs + ) + results.append(status) + + result = all(results) + return SecurityCheckStatus.SUCCESS if result else SecurityCheckStatus.FAIL diff --git a/app/secbot/inputs/gitlab/__init__.py b/app/secbot/inputs/gitlab/__init__.py new file mode 100755 index 0000000..1d5f598 --- /dev/null +++ b/app/secbot/inputs/gitlab/__init__.py @@ -0,0 +1,127 @@ +from sqlalchemy import select + +from app.secbot.config import config +from app.secbot.db import db_session +from app.secbot.inputs import SecbotInput +from app.secbot.inputs.gitlab.models import ( + RepositorySecurityCheck, + RepositorySecurityScan, +) +from app.secbot.inputs.gitlab.schemas import ( + AnyGitlabModel, + GitlabEvent, + GitlabInputData, + GitlabWebhookSecurityID, +) +from app.secbot.inputs.gitlab.services import get_or_create_security_check +from app.secbot.inputs.gitlab.utils import ( + generate_gitlab_security_id, + get_config_from_host, +) +from app.secbot.logger import logger +from app.secbot.schemas import ScanStatus, SecurityCheckStatus + + +# noinspection PyMethodOverriding +class GitlabInput(SecbotInput): + async def run( + self, + data: AnyGitlabModel, + event: GitlabEvent, + ): + job = config.matching_workflow_job("gitlab", data.raw) + if not job: + logger.info(f"No matching workflow job for {event}") + return + + gitlab_config = get_config_from_host(data.repository.homepage.host) + security_id = generate_gitlab_security_id(gitlab_config.prefix, data=data) + + async with db_session() as session: + check = await get_or_create_security_check( + db_session=session, + external_id=security_id, + initial_data={ + "event_type": event, + "event_json": data.raw, + "commit_hash": data.commit.id, + "branch": data.target_branch, + "project_name": data.repository.name, + "path": data.repository.homepage, + "prefix": gitlab_config.prefix, + }, + ) + input_data = GitlabInputData( + event=check.event_type, + data=data, + db_check_id=check.id, + ) + return await super().run(input_data, job=job) + + async def fetch_status( + self, security_check_id: GitlabWebhookSecurityID + ) -> SecurityCheckStatus: + async with db_session() as session: + check = ( + await session.execute( + select(RepositorySecurityCheck).where( + RepositorySecurityCheck.external_id == security_check_id + ) + ) + ).scalar() + if not check: + return SecurityCheckStatus.NOT_STARTED + + scans = ( + await session.execute( + select( + [ + RepositorySecurityScan.status, + RepositorySecurityScan.scan_name, + RepositorySecurityScan.outputs_test_id, + ] + ).where(RepositorySecurityScan.check_id == check.id) + ) + ).all() + + # Define if we have enough scans + # we suppose that we have only one job for a security check + job = config.matching_workflow_job("gitlab", check.event_json) + has_enough_scans = len(scans) == len(job.scans) + + # If we have not enough scans, we should wait for them + if not has_enough_scans: + return SecurityCheckStatus.IN_PROGRESS + + # If for some reason we have more scans than jobs + if len(scans) > len(job.scans): + return SecurityCheckStatus.ERROR + + # Remove skipped scans from checks + scans = [scan for scan in scans if scan.status is not ScanStatus.SKIP] + statuses = [scan.status for scan in scans if scan] + + if ScanStatus.ERROR in statuses: + return SecurityCheckStatus.ERROR + elif ScanStatus.IN_PROGRESS in statuses: + return SecurityCheckStatus.IN_PROGRESS + + if all(status == ScanStatus.DONE for status in statuses): + scan_outputs = set( + output_name + for scan in scans + for output_name in scan.outputs_test_id.keys() + ) + outputs = [ + output for output in job.outputs if output.name in scan_outputs + ] + scan_names = set(scan.scan_name for scan in scans) + eligible_scans = [ + scan for scan in job.scans if scan.name in scan_names + ] + return await super().fetch_status( + outputs, + eligible_scans=eligible_scans, + commit_hash=check.commit_hash, + ) + return SecurityCheckStatus.ERROR diff --git a/app/secbot/inputs/gitlab/dependencies.py b/app/secbot/inputs/gitlab/dependencies.py new file mode 100755 index 0000000..111af30 --- /dev/null +++ b/app/secbot/inputs/gitlab/dependencies.py @@ -0,0 +1,376 @@ +from __future__ import annotations + +import logging +from typing import Optional + +from fastapi import Body, Depends, Header, HTTPException, Request +from pydantic import ValidationError + +from app.secbot.inputs.gitlab.schemas import ( + AnyGitlabModel, + GitlabEvent, + get_gitlab_model_for_event, +) +from app.settings import settings + +logger = logging.getLogger(__name__) + + +def get_gitlab_webhook_token_header(x_gitlab_token: str = Header(None)) -> str: + tokens = [ + config.webhook_secret_token.get_secret_value() + for config in settings.gitlab_configs + ] + # TODO: add auth for projects based on token + if x_gitlab_token not in tokens: + raise HTTPException(status_code=403, detail="X-Gitlab-Token header is invalid") + return x_gitlab_token + + +async def gitlab_event( + request: Request, + x_gitlab_event: Optional[str] = Header(None), +) -> Optional[GitlabEvent]: + """Get GitlabEvent model from http request. + + We may have any types of events, not only which we support. + If we don't support event, we just return 200 to the gitlab and do nothing. + """ + + # System Hook happens when event triggered by gitlab itself + if x_gitlab_event == "System Hook": + event_map = { + "merge_request": GitlabEvent.MERGE_REQUEST, + "push": GitlabEvent.PUSH, + "tag_push": GitlabEvent.TAG_PUSH, + } + body = await request.json() + # NOTE(ivan.zhirov): For some reason gitlab has different event key names + # for different events. + # PUSH - event_name + # TAG_PUSH - event_name + # MERGE_REQUEST - event_type + event_name = body.get("event_name", body.get("event_type")) + try: + return event_map[event_name] + except KeyError: + return None + + # Web Hook happens when event triggered by particular project + try: + return GitlabEvent(x_gitlab_event) + except ValueError: + return None + + +def webhook_model( + body: dict = Body( + examples={ + GitlabEvent.MERGE_REQUEST: { + "value": { + "object_kind": "merge_request", + "event_type": "merge_request", + "user": { + "id": 1, + "name": "Administrator", + "username": "root", + "avatar_url": "https://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon", + "email": "admin@example.com", + }, + "project": { + "id": 1, + "name": "Gitlab Test", + "description": "Aut reprehenderit ut est.", + "web_url": "https://example.com/gitlabhq/gitlab-test", + "avatar_url": None, + "git_ssh_url": "git@example.com:gitlabhq/gitlab-test.git", + "git_http_url": "https://example.com/gitlabhq/gitlab-test.git", + "namespace": "GitlabHQ", + "visibility_level": 20, + "path_with_namespace": "gitlabhq/gitlab-test", + "default_branch": "master", + "homepage": "https://example.com/gitlabhq/gitlab-test", + "url": "https://example.com/gitlabhq/gitlab-test.git", + "ssh_url": "git@example.com:gitlabhq/gitlab-test.git", + "http_url": "https://example.com/gitlabhq/gitlab-test.git", + }, + "repository": { + "name": "Gitlab Test", + "url": "https://example.com/gitlabhq/gitlab-test.git", + "description": "Aut reprehenderit ut est.", + "homepage": "https://example.com/gitlabhq/gitlab-test", + }, + "object_attributes": { + "id": 99, + "iid": 1, + "target_branch": "master", + "source_branch": "ms-viewport", + "source_project_id": 14, + "author_id": 51, + "assignee_ids": [6], + "assignee_id": 6, + "reviewer_ids": [6], + "title": "MS-Viewport", + "created_at": "2013-12-03T17:23:34Z", + "updated_at": "2013-12-03T17:23:34Z", + "milestone_id": None, + "state": "opened", + "blocking_discussions_resolved": True, + "work_in_progress": False, + "first_contribution": True, + "merge_status": "unchecked", + "target_project_id": 14, + "description": "", + "url": "https://example.com/diaspora/merge_requests/1", + "source": { + "name": "Awesome Project", + "description": "Aut reprehenderit ut est.", + "web_url": "https://example.com/awesome_space/awesome_project", + "avatar_url": None, + "git_ssh_url": "git@example.com:awesome_space/awesome_project.git", + "git_http_url": "https://example.com/awesome_space/awesome_project.git", + "namespace": "Awesome Space", + "visibility_level": 20, + "path_with_namespace": "awesome_space/awesome_project", + "default_branch": "master", + "homepage": "https://example.com/awesome_space/awesome_project", + "url": "https://example.com/awesome_space/awesome_project.git", + "ssh_url": "git@example.com:awesome_space/awesome_project.git", + "http_url": "https://example.com/awesome_space/awesome_project.git", + }, + "target": { + "name": "Awesome Project", + "description": "Aut reprehenderit ut est.", + "web_url": "https://example.com/awesome_space/awesome_project", + "avatar_url": None, + "git_ssh_url": "git@example.com:awesome_space/awesome_project.git", + "git_http_url": "https://example.com/awesome_space/awesome_project.git", + "namespace": "Awesome Space", + "visibility_level": 20, + "path_with_namespace": "awesome_space/awesome_project", + "default_branch": "master", + "homepage": "https://example.com/awesome_space/awesome_project", + "url": "https://example.com/awesome_space/awesome_project.git", + "ssh_url": "git@example.com:awesome_space/awesome_project.git", + "http_url": "https://example.com/awesome_space/awesome_project.git", + }, + "last_commit": { + "id": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "message": "fixed readme", + "timestamp": "2012-01-03T23:36:29+02:00", + "url": "https://example.com/awesome_space/awesome_project/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "author": { + "name": "GitLab dev user", + "email": "gitlabdev@dv6700.(none)", + }, + }, + "labels": [ + { + "id": 206, + "title": "API", + "color": "#ffffff", + "project_id": 14, + "created_at": "2013-12-03T17:15:43Z", + "updated_at": "2013-12-03T17:15:43Z", + "template": False, + "description": "API related issues", + "type": "ProjectLabel", + "group_id": 41, + } + ], + "action": "open", + "detailed_merge_status": "mergeable", + }, + "labels": [ + { + "id": 206, + "title": "API", + "color": "#ffffff", + "project_id": 14, + "created_at": "2013-12-03T17:15:43Z", + "updated_at": "2013-12-03T17:15:43Z", + "template": False, + "description": "API related issues", + "type": "ProjectLabel", + "group_id": 41, + } + ], + "changes": { + "updated_by_id": {"previous": None, "current": 1}, + "updated_at": { + "previous": "2017-09-15 16:50:55 UTC", + "current": "2017-09-15 16:52:00 UTC", + }, + "labels": { + "previous": [ + { + "id": 206, + "title": "API", + "color": "#ffffff", + "project_id": 14, + "created_at": "2013-12-03T17:15:43Z", + "updated_at": "2013-12-03T17:15:43Z", + "template": False, + "description": "API related issues", + "type": "ProjectLabel", + "group_id": 41, + } + ], + "current": [ + { + "id": 205, + "title": "Platform", + "color": "#123123", + "project_id": 14, + "created_at": "2013-12-03T17:15:43Z", + "updated_at": "2013-12-03T17:15:43Z", + "template": False, + "description": "Platform related issues", + "type": "ProjectLabel", + "group_id": 41, + } + ], + }, + }, + "assignees": [ + { + "id": 6, + "name": "User1", + "username": "user1", + "avatar_url": "https://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon", + } + ], + "reviewers": [ + { + "id": 6, + "name": "User1", + "username": "user1", + "avatar_url": "https://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon", + } + ], + } + }, + GitlabEvent.TAG_PUSH: { + "value": { + "object_kind": "tag_push", + "event_name": "tag_push", + "before": "0000000000000000000000000000000000000000", + "after": "82b3d5ae55f7080f1e6022629cdb57bfae7cccc7", + "ref": "refs/tags/v1.0.0", + "checkout_sha": "82b3d5ae55f7080f1e6022629cdb57bfae7cccc7", + "user_id": 1, + "user_name": "John Smith", + "user_avatar": "https://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=8://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=80", + "project_id": 1, + "project": { + "id": 1, + "name": "Example", + "description": "", + "web_url": "https://example.com/jsmith/example", + "avatar_url": None, + "git_ssh_url": "git@example.com:jsmith/example.git", + "git_http_url": "https://example.com/jsmith/example.git", + "namespace": "Jsmith", + "visibility_level": 0, + "path_with_namespace": "jsmith/example", + "default_branch": "master", + "homepage": "https://example.com/jsmith/example", + "url": "git@example.com:jsmith/example.git", + "ssh_url": "git@example.com:jsmith/example.git", + "http_url": "https://example.com/jsmith/example.git", + }, + "repository": { + "name": "Example", + "url": "ssh://git@example.com/jsmith/example.git", + "description": "", + "homepage": "https://example.com/jsmith/example", + "git_http_url": "https://example.com/jsmith/example.git", + "git_ssh_url": "git@example.com:jsmith/example.git", + "visibility_level": 0, + }, + "commits": [], + "total_commits_count": 0, + } + }, + GitlabEvent.PUSH: { + "value": { + "object_kind": "push", + "event_name": "push", + "before": "95790bf891e76fee5e1747ab589903a6a1f80f22", + "after": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "ref": "refs/heads/master", + "checkout_sha": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "user_id": 4, + "user_name": "John Smith", + "user_username": "jsmith", + "user_email": "john@example.com", + "user_avatar": "https://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=8://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=80", + "project_id": 15, + "project": { + "id": 15, + "name": "Diaspora", + "description": "", + "web_url": "https://example.com/mike/diaspora", + "avatar_url": None, + "git_ssh_url": "git@example.com:mike/diaspora.git", + "git_http_url": "https://example.com/mike/diaspora.git", + "namespace": "Mike", + "visibility_level": 0, + "path_with_namespace": "mike/diaspora", + "default_branch": "master", + "homepage": "https://example.com/mike/diaspora", + "url": "git@example.com:mike/diaspora.git", + "ssh_url": "git@example.com:mike/diaspora.git", + "http_url": "https://example.com/mike/diaspora.git", + }, + "repository": { + "name": "Diaspora", + "url": "git@example.com:mike/diaspora.git", + "description": "", + "homepage": "https://example.com/mike/diaspora", + "git_http_url": "https://example.com/mike/diaspora.git", + "git_ssh_url": "git@example.com:mike/diaspora.git", + "visibility_level": 0, + }, + "commits": [ + { + "id": "b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327", + "message": "Update Catalan translation to e38cb41.\n\nSee https://gitlab.com/gitlab-org/gitlab for more information", + "title": "Update Catalan translation to e38cb41.", + "timestamp": "2011-12-12T14:27:31+02:00", + "url": "https://example.com/mike/diaspora/commit/b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327", + "author": { + "name": "Jordi Mallach", + "email": "jordi@softcatala.org", + }, + "added": ["CHANGELOG"], + "modified": ["app/controller/application.rb"], + "removed": [], + }, + { + "id": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "message": "fixed readme", + "title": "fixed readme", + "timestamp": "2012-01-03T23:36:29+02:00", + "url": "https://example.com/mike/diaspora/commit/da1560886d4f094c3e6c9ef40349f7d38b5d27d7", + "author": { + "name": "GitLab dev user", + "email": "gitlabdev@dv6700.(none)", + }, + "added": ["CHANGELOG"], + "modified": ["app/controller/application.rb"], + "removed": [], + }, + ], + "total_commits_count": 4, + } + }, + } + ), + event: Optional[GitlabEvent] = Depends(gitlab_event), +) -> Optional[AnyGitlabModel]: + """Get GitlabEvent model base.""" + try: + return get_gitlab_model_for_event(event, body) + except (KeyError, ValidationError): + return None diff --git a/app/secbot/inputs/gitlab/handlers/__init__.py b/app/secbot/inputs/gitlab/handlers/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/app/secbot/inputs/gitlab/handlers/defectdojo/__init__.py b/app/secbot/inputs/gitlab/handlers/defectdojo/__init__.py new file mode 100755 index 0000000..f311b24 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/defectdojo/__init__.py @@ -0,0 +1,88 @@ +import json +from typing import List + +from pydantic import AnyUrl + +from app.secbot.config import SecbotConfigComponent +from app.secbot.handlers import SecbotOutputHandler +from app.secbot.inputs.gitlab.handlers.defectdojo.services import ( + OutputResultObject, + send_result, +) +from app.secbot.inputs.gitlab.handlers.defectdojo.validator import ( + DefectDojoFindingsValidator, +) +from app.secbot.inputs.gitlab.schemas import GitlabOutputResult, GitlabScanResult +from app.secbot.inputs.gitlab.schemas.output_responses import OutputResponse +from app.secbot.inputs.gitlab.services import complete_scan, handle_exception +from app.secbot.inputs.gitlab.utils import get_project_name +from app.secbot.schemas import SecbotBaseModel + + +class DefectDojoCredentials(SecbotBaseModel): + url: AnyUrl + secret_key: str + user: str + lead_id: int + + +# noinspection PyMethodOverriding +class DefectDojoHandler(SecbotOutputHandler): + env_model = DefectDojoCredentials + + async def on_failure( + self, + scan_result: GitlabScanResult, + exception, + component_name: str, + env: DefectDojoCredentials, + ): + await handle_exception( + check_id=scan_result.input.db_check_id, + scan_component_name=scan_result.component_name, + exception=exception, + ) + + async def fetch_status( + self, + eligible_scans: List[SecbotConfigComponent], + commit_hash: str, + env: DefectDojoCredentials, + ) -> bool: + dd_validator = DefectDojoFindingsValidator( + eligible_scans=eligible_scans, + credentials=env, + commit_hash=commit_hash, + ) + return await dd_validator.is_valid() + + async def run( + self, + scan_result: GitlabScanResult, + component_name: str, + env: DefectDojoCredentials, + ): + test_id, dd_findings = await send_result( + credentials=env, + output_result=OutputResultObject( + data=scan_result.input.data, + worker=scan_result.handler_name, + result=json.dumps(scan_result.file.content), + ), + ) + await complete_scan( + scan_id=scan_result.db_id, + output_component_name=component_name, + output_external_test_id=test_id, + ) + response = OutputResponse( + project_name=get_project_name(scan_result.input.data.project.git_ssh_url), + project_url=scan_result.input.data.project.web_url, + findings=dd_findings, + ) + return GitlabOutputResult( + handler_name=self.config_name, + component_name=component_name, + scan_result=scan_result, + response=response, + ) diff --git a/app/secbot/inputs/gitlab/handlers/defectdojo/api.py b/app/secbot/inputs/gitlab/handlers/defectdojo/api.py new file mode 100755 index 0000000..7f74c31 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/defectdojo/api.py @@ -0,0 +1,767 @@ +import json +import logging +from typing import List + +import aiohttp + +from app.secbot.logger import logger + +version = "1.2.0." + + +class DefectDojoAPIv2(object): + """An API wrapper for DefectDojo.""" + + def __init__( + self, + host, + api_token, + user, + api_version="v2", + timeout=60, + debug=False, + ): + """Initialize a DefectDojo API instance. + + :param host: The URL for the DefectDojo server. (e.g., http://localhost:8000/DefectDojo/) + :param api_token: The API token generated on the DefectDojo API key page. + :param user: The user associated with the API key. + :param api_version: API version to call, the default is v2. + :param timeout: HTTP timeout in seconds, default is 30. + :param debug: Prints requests and responses, useful for debugging. + + """ + + self.host = host + "/api/" + api_version + "/" + self.api_token = api_token + self.user = user + self.api_version = api_version + self.timeout = timeout + self.logger = logger + + if debug: + self.logger.setLevel(logging.DEBUG) + + # Engagements API + async def list_engagements( + self, + status=None, + product_id=None, + name_contains=None, + name=None, + limit=20, + offset=0, + ): + """Retrieves all the engagements. + + :param product_in: List of product ids (1,2). + :param name_contains: Engagement name + :param limit: Number of records to return. + :param offset: The initial index from which to return the result + + """ + + params = {} + if limit: + params["limit"] = limit + + if offset: + params["offset"] = offset + + if product_id: + params["product"] = product_id + + if status: + params["status"] = status + + # TODO remove name_contains here, or add to Defect Dojo. Currently it does nothing + if name_contains: + params["name_contains"] = name_contains + + if name: + params["name"] = name + + return await self._request("GET", "engagements/", params) + + async def create_engagement( + self, + name, + product_id, + lead_id, + status, + target_start, + target_end, + active="True", + pen_test="False", + check_list="False", + threat_model="False", + risk_path="", + test_strategy="", + progress="", + done_testing="False", + engagement_type="CI/CD", + build_id=None, + commit_hash=None, + branch_tag=None, + build_server=None, + source_code_management_server=None, + source_code_management_uri=None, + orchestration_engine=None, + description=None, + deduplication_on_engagement=True, + ): + """Creates an engagement with the given properties. + + :param name: Engagement name. + :param product_id: Product key id. + :param lead_id: Testing lead from the user table. + :param status: Engagement Status: In Progress, On Hold, Completed. + :param target_start: Engagement start date. + :param target_end: Engagement end date. + :param active: Active + :param pen_test: Pen test for engagement. + :param check_list: Check list for engagement. + :param threat_model: Thread Model for engagement. + :param risk_path: risk_path + :param test_strategy: Test Strategy URLs + :param progress: Engagement progress measured in percent. + :param engagement_type: Interactive or CI/CD + :param build_id: Build id from the build server + :param commit_hash: Commit hash from source code management + :param branch_tag: Branch or tag from source code management + :param build_server: Tool Configuration id of build server + :param source_code_management_server: URL of source code management + :param source_code_management_uri: Link to source code commit + :param orchestration_engine: URL of orchestration engine + :param deduplication_on_engagement: boolean value for deduplication_on_engagement + + """ + + data = { + "name": name, + "product": product_id, + "lead": lead_id, + "status": status, + "target_start": target_start, + "target_end": target_end, + "active": active, + "pen_test": pen_test, + "check_list": check_list, + "threat_model": threat_model, + "risk_path": risk_path, + "test_strategy": test_strategy, + "progress": progress, + "done_testing": done_testing, + "engagement_type": engagement_type, + } + + if description: + data.update({"description": description}) + + if build_id: + data.update({"build_id": build_id}) + + if commit_hash: + data.update({"commit": commit_hash}) + + if branch_tag: + data.update({"branch_tag": branch_tag}) + + if build_server: + data.update({"build_server": build_server}) + + if source_code_management_server: + data.update( + {"source_code_management_server": source_code_management_server} + ) + + if source_code_management_uri: + data.update({"source_code_management_uri": source_code_management_uri}) + + if orchestration_engine: + data.update({"orchestration_engine": orchestration_engine}) + + if deduplication_on_engagement: + data.update({"deduplication_on_engagement": deduplication_on_engagement}) + + return await self._request("POST", "engagements/", data=data) + + async def set_engagement( + self, + id, + product_id=None, + lead_id=None, + name=None, + status=None, + target_start=None, + target_end=None, + active=None, + pen_test=None, + check_list=None, + threat_model=None, + risk_path=None, + test_strategy=None, + progress=None, + done_testing=None, + engagement_type="CI/CD", + build_id=None, + commit_hash=None, + branch_tag=None, + build_server=None, + source_code_management_server=None, + source_code_management_uri=None, + orchestration_engine=None, + description=None, + ): + + """Updates an engagement with the given properties. + + :param id: Engagement id. + :param name: Engagement name. + :param product_id: Product key id. + :param lead_id: Testing lead from the user table. + :param status: Engagement Status: In Progress, On Hold, Completed. + :param target_start: Engagement start date. + :param target_end: Engagement end date. + :param active: Active + :param pen_test: Pen test for engagement. + :param check_list: Check list for engagement. + :param threat_model: Thread Model for engagement. + :param risk_path: risk_path + :param test_strategy: Test Strategy URLs + :param progress: Engagement progress measured in percent. + :param engagement_type: Interactive or CI/CD + :param build_id: Build id from the build server + :param commit_hash: Commit hash from source code management + :param branch_tag: Branch or tag from source code management + :param build_server: Tool Configuration id of build server + :param source_code_management_server: URL of source code management + :param source_code_management_uri: Link to source code commit + :param orchestration_engine: URL of orchestration engine + """ + + data = {} + + if name: + data["name"] = name + + if product_id: + data["product"] = product_id + + if lead_id: + data["lead"] = lead_id + + if status: + data["status"] = status + + if target_start: + data["target_start"] = target_start + + if target_end: + data["target_end"] = target_end + + if active is not None: + data["active"] = active + + if pen_test: + data["pen_test"] = pen_test + + if check_list: + data["check_list"] = check_list + + if threat_model: + data["threat_model"] = threat_model + + if risk_path: + data["risk_path"] = risk_path + + if test_strategy: + data["test_strategy"] = test_strategy + + if progress: + data["progress"] = progress + + if done_testing: + data["done_testing"] = done_testing + + if build_id: + data["build_id"] = build_id + + if commit_hash: + data["commit"] = commit_hash + + if description: + data["description"] = description + + return await self._request("PATCH", "engagements/" + str(id) + "/", data=data) + + async def list_products(self, name=None, name_contains=None, limit=200, offset=0): + + """Retrieves all the products. + + :param name: Search by product name. + :param name_contains: Search by product name. + :param limit: Number of records to return. + :param offset: The initial index from which to return the results. + + """ + + params = {} + if limit: + params["limit"] = limit + + if offset: + params["offset"] = offset + + if name: + params["name"] = name + + if name_contains: + params["name__icontains"] = name_contains + + return await self._request("GET", "products/", params) + + async def create_product(self, name, description, prod_type): + """Creates a product with the given properties. + + :param name: Product name. + :param description: Product description.. + :param prod_type: Product type. + + """ + + data = {"name": name, "description": description, "prod_type": prod_type} + + return await self._request("POST", "products/", data=data) + + async def get_test(self, test_id): + """Retrieves a test using the given test id. + + :param test_id: Test identification. + + """ + return await self._request("GET", "tests/" + str(test_id) + "/") + + # Findings API + async def list_findings( + self, + active=None, + duplicate=None, + mitigated=None, + severity=None, + verified=None, + severity_lt=None, + severity_gt=None, + severity_contains=None, + title_contains=None, + url_contains=None, + date_lt=None, + date_gt=None, + date=None, + product_id_in=None, + engagement_id_in=None, + test_id_in=None, + build=None, + prefetch: List[str] = None, + test_tags: List[str] = None, + related_fields: bool = False, + limit=20, + offset=0, + ): + + """Returns filtered list of findings. + + :param active: Finding is active: (true or false) + :param duplicate: Duplicate finding (true or false) + :param mitigated: Mitigated finding (true or false) + :param severity: Severity: Low, Medium, High and Critical. + :param verified: Finding verified. + :param severity_lt: Severity less than Low, Medium, High and Critical. + :param severity_gt: Severity greater than Low, Medium, High and Critical. + :param severity_contains: Severity contains: (Medium, Critical) + :param title_contains: Filter by title containing the keyword. + :param url_contains: Filter by URL containing the keyword. + :param date_lt: Date less than. + :param date_gt: Date greater than. + :param date: Return findings for a particular date. + :param product_id_in: Product id(s) associated with a finding. (1,2 or 1) + :param engagement_id_in: Engagement id(s) associated with a finding. (1,2 or 1) + :param test_in: Test id(s) associated with a finding. (1,2 or 1) + :param build_id: User specified build id relating to the build number + from the build server. (Jenkins, Travis etc.). + :param limit: Number of records to return. + :param offset: The initial index from which to return the results + + """ + + params = {} + if limit: + params["limit"] = limit + + if offset: + params["offset"] = offset + + if active: + params["active"] = active + + if duplicate: + params["duplicate"] = duplicate + + if mitigated: + params["mitigated"] = mitigated + + if severity: + params["severity__in"] = severity + + if verified: + params["verified"] = verified + + if severity_lt: + params["severity__lt"] = severity_lt + + if severity_gt: + params["severity__gt"] = severity_gt + + if severity_contains: + params["severity"] = severity_contains + + if title_contains: + params["title"] = title_contains + + if url_contains: + params["url__contains"] = url_contains + + if date_lt: + params["date__lt"] = date_lt + + if date_gt: + params["date__gt"] = date_gt + + if date: + params["date"] = date + + if engagement_id_in: + params["test__engagement"] = engagement_id_in + + if product_id_in: + params["test__engagement__product"] = product_id_in + + if test_id_in: + params["test"] = test_id_in + + if build: + params["build_id__contains"] = build + + if prefetch: + params["prefetch"] = ",".join(prefetch) + + if test_tags: + params["test__tags"] = ",".join(test_tags) + + if related_fields: + params["related_fields"] = "true" + + return await self._request("GET", "findings/", params) + + # Upload API + async def upload_scan( + self, + engagement_id, + scan_type, + file, + active, + verified, + close_old_findings, + skip_duplicates, + scan_date, + build="", + tags=None, + version=None, + branch_tag=None, + commit_hash=None, + minimum_severity="Info", + auto_group_by=None, + ): + """Uploads and processes a scan file. + + :param application_id: Application identifier. + :param file_path: Path to the scan file to be uploaded. + + """ + if build is None: + build = "" + + with open(file, "rb") as f: + filedata = f.read() + + self.logger.debug("filedata:") + self.logger.debug(filedata) + + data = { + "file": filedata, + "engagement": engagement_id, + "scan_type": scan_type, + "active": active, + "verified": verified, + "close_old_findings": close_old_findings, + "skip_duplicates": skip_duplicates, + "scan_date": scan_date, + "tags": tags, + "build_id": build, + "version": version, + "branch_tag": branch_tag, + "commit_hash": commit_hash, + "minimum_severity": minimum_severity, + # 'push_to_jira': ('', True) + } + if auto_group_by: + data["auto_group_by"] = auto_group_by + + """ + TODO: implement these parameters: + lead + test_type + scan_date + """ + return await self._request("POST", "import-scan/", files=data) + + async def list_language_types(self, id=None, language_name=None, limit=20): + """Retrieves source code languages. + + :param id: Search by language id. + :param language_name: Search by language name + :param limit: Number of records to return. + + """ + + params = {} + if limit: + params["limit"] = limit + + if id: + params["id"] = id + + if language_name: + params["language__icontains"] = language_name + + return await self._request("GET", "language_types/", params) + + async def list_products_type(self, id=None, name=None, limit=100, offset=0): + """ + Retrieves product types + + :param id: Search for a specific product type ID + :param name: Search a specific product type key + :param limit: Number of records to return. + :param offset: The initial index from which to return the result + """ + + params = {} + if id: + params["id"] = id + + if name: + params["name"] = name + + if limit: + params["limit"] = limit + + if offset: + params["offset"] = offset + + return await self._request("GET", "product_types/", params) + + # Utility + + @staticmethod + def _build_list_params(param_name, key, values): + """Builds a list of POST parameters from a list or single value.""" + params = {} + if hasattr(values, "__iter__"): + index = 0 + for value in values: + params[str(param_name) + "[" + str(index) + "]." + str(key)] = str( + value + ) + index += 1 + else: + params[str(param_name) + "[0]." + str(key)] = str(values) + return params + + @staticmethod + def _sanitize_multipart_data(data): + ret = {} + for name, value in data.items(): + if value is None: + continue + if isinstance(value, bool): + value = "true" if value else "false" + ret[name] = value + return ret + + async def _request(self, method, url, params=None, data=None, files=None): + """Common handler for all HTTP requests.""" + if not params: + params = {} + + if data: + data = json.dumps(data) + if files: + data = self._sanitize_multipart_data(files) + + headers = { + "Authorization": ( + ("ApiKey " + self.user + ":" + self.api_token) + if (self.api_version == "v1") + else ("Token " + self.api_token) + ), + } + + if not files: + headers["Accept"] = "application/json" + headers["Content-Type"] = "application/json" + + self.logger.debug("request:") + self.logger.debug(method + " " + url) + self.logger.debug("headers: " + str(headers)) + self.logger.debug("params:" + str(params)) + self.logger.debug("data:" + str(data)) + self.logger.debug("files:" + str(files)) + + try: + async with aiohttp.ClientSession(raise_for_status=True) as session: + response = await session.request( + method=method, + url=self.host + url, + params=params, + data=data, + headers=headers, + timeout=self.timeout, + ) + status_code = response.status + text = await response.text() + data = await response.json() + + self.logger.debug("response:") + self.logger.debug(status_code) + self.logger.debug(text) + try: + if status_code == 201: # Created new object + try: + object_id = response.headers["Location"].split("/") + key_id = object_id[-2] + data = int(key_id) + except Exception: + pass + + return DefectDojoResponse( + message="Upload complete", + response_code=status_code, + data=data, + success=True, + ) + elif status_code == 204: # Object updates + return DefectDojoResponse( + message="Object updated.", + response_code=status_code, + success=True, + ) + elif status_code == 400: # Object not created + return DefectDojoResponse( + message="Error occurred in API.", + response_code=status_code, + success=False, + data=text, + ) + elif status_code == 404: # Object not created + return DefectDojoResponse( + message="Object id does not exist.", + response_code=status_code, + success=False, + data=text, + ) + elif status_code == 401: + return DefectDojoResponse( + message="Unauthorized.", + response_code=status_code, + success=False, + data=text, + ) + elif status_code == 414: + return DefectDojoResponse( + message="Request-URI Too Large.", + response_code=status_code, + success=False, + ) + elif status_code == 500: + return DefectDojoResponse( + message="An error 500 occurred in the API.", + response_code=status_code, + success=False, + data=text, + ) + else: + return DefectDojoResponse( + message="Success", + data=data, + success=True, + response_code=status_code, + ) + except ValueError: + return DefectDojoResponse( + message="JSON response could not be decoded.", + response_code=status_code, + success=False, + data=text, + ) + except aiohttp.ClientResponseError as e: + self.logger.warning("There was an error while handling the request.") + self.logger.exception(e) + return DefectDojoResponse( + message="There was an error while handling the request.", + response_code=e.status, + success=False, + ) + + +class DefectDojoResponse(object): + """ + Container for all DefectDojo API responses, even errors. + + """ + + def __init__(self, message, success, data=None, response_code=-1): + self.message = message + self.data = data + self.success = success + self.response_code = response_code + self.logger = logger + + def __str__(self): + if self.data: + return str(self.data) + else: + return self.message + + def id(self): + self.logger.debug("response_code" + str(self.response_code)) + if self.response_code == 400: # Bad Request + raise ValueError( + "Object not created:" + + json.dumps( + self.data, sort_keys=True, indent=4, separators=(",", ": ") + ) + ) + return int(self.data["id"]) + + def count(self): + return self.data["count"] + + def data_json(self, pretty=False): + """Returns the data as a valid JSON string.""" + if pretty: + return json.dumps( + self.data, sort_keys=True, indent=4, separators=(",", ": ") + ) + else: + return json.dumps(self.data) diff --git a/app/secbot/inputs/gitlab/handlers/defectdojo/services.py b/app/secbot/inputs/gitlab/handlers/defectdojo/services.py new file mode 100755 index 0000000..0dd1cad --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/defectdojo/services.py @@ -0,0 +1,326 @@ +import asyncio +import json +import tempfile +from datetime import date +from pprint import pformat +from typing import List, Tuple, cast +from urllib.parse import urlparse + +import requests +import yarl +from pydantic import AnyUrl, BaseModel + +import app.secbot.inputs.gitlab.handlers.defectdojo.api as defectdojo +from app.secbot import logger +from app.secbot.inputs.gitlab.schemas import AnyGitlabModel +from app.secbot.inputs.gitlab.schemas.output_responses import OutputFinding +from app.secbot.schemas import Severity + +WORKER_TO_SCAN_TYPE_MAPPER = { + "gitleaks": "Gitleaks Scan", +} + + +class OutputResultObject(BaseModel): + data: AnyGitlabModel + worker: str + result: str + + +class DefectDojoCredentials(BaseModel): + url: AnyUrl + secret_key: str + user: str + lead_id: int + + +def handle_dd_response(resp, context="", raise_on_error=True): + if ( + resp.response_code not in (200, 201) + or resp.success is not True + or isinstance(resp.data, str) + ): + if context: + context = f", context: {context}" + error_msg = ( + f"[!] Error. Message: {resp.message}. " + f"Status_code: {resp.response_code}, data: {pformat(resp.data)}, {context}" + ) + if raise_on_error: + raise RuntimeError(error_msg) + if isinstance(resp.data, dict) or isinstance(resp.data, list): + return resp.data + try: + return json.loads(resp.data) + except Exception: + return {"error": str(resp.data)} + # return json data if everything is good + return resp.data + + +async def dd_prepare( + credentials: DefectDojoCredentials, + product_type: str, + product_name: str, + product_description: str, + repo_url: AnyUrl, + name: str, + commit_hash: str, + description: str, +): + dd = defectdojo.DefectDojoAPIv2( + credentials.url, + credentials.secret_key, + credentials.user, + debug=False, + timeout=360, + ) + # Check if product type already exists. Create one if it doesn't exist + product_type_dd = await dd.list_products_type(name=product_type) + product_type_dd_parsed = handle_dd_response(product_type_dd, product_type) + product_types = cast(List[dict], product_type_dd_parsed["results"]) + if len(product_types) > 0: + product_types = [pt for pt in product_types if pt["name"] == product_type] + if len(product_types) > 0: + product_type_id = product_types[0]["id"] + logger.info( + f"[x] Product type '{product_type}' already exists, getting the first one (#{product_type_id})" + ) + else: + # product type is being created with a direct API call due to the absence of an appropriate + # wrapper method in defectdojo_apiv2 + try: + logger.info(f"[x] Create product type {product_type}") + # todo: async + response = requests.post( + f"{credentials.url}/api/v2/product_types/", + headers={"Authorization": f"Token {credentials.secret_key}"}, + json={"name": product_type}, + verify=False, + ) + response.raise_for_status() + product_type_id = response.json()["id"] + except Exception: + logger.info(f'[!] Error. Cannot create product type "{product_type}"') + raise + + # Check if product already exists. Create one if it doesn't exist + product_dd = await dd.list_products(name=product_name) + product_dd_parsed = handle_dd_response(product_dd, product_name) + products = cast(List[dict], product_dd_parsed["results"]) + if len(products) > 0: + products = [ + product + for product in products + if product["name"] == product_name + and product["prod_type"] == product_type_id + ] + if len(products) > 0: + product_id = products[0]["id"] + logger.info( + f"[x] Product '{product_name}' already exists, getting the first one (#{product_id})" + ) + else: + # create product if it doesn't exist + logger.info(f"[x] Create product {product_name}") + product = await dd.create_product( + product_name, + product_description, + product_type_id, + ) + product = handle_dd_response(product, product_name) + product_id = product["id"] + + engagement_dd = await dd.list_engagements(name=name) + engagement_dd_parsed = handle_dd_response(engagement_dd, name) + engagements = cast(List[dict], engagement_dd_parsed["results"]) + if len(engagements) > 0: + engagements = [ + engagement + for engagement in engagements + if engagement["name"] == name and engagement["product"] == product_id + ] + if len(engagements) > 0: + engagement_id = engagements[0]["id"] + engagement_name = engagements[0]["name"] + logger.info( + f"[x] Engagement '{engagement_name}' already exists, getting the first one (#{engagement_id})" + ) + else: + # create the engagement if we didn't find one + engagement_data = { + "name": f"{name}", + "product_id": product_id, + "lead_id": credentials.lead_id, + "status": "Completed", + "target_start": f'{date.today().strftime("%Y-%m-%d")}', + "target_end": f'{date.today().strftime("%Y-%m-%d")}', + "engagement_type": "CI/CD", + "deduplication_on_engagement": False, + "build_id": f"{name}", + "commit_hash": f"{commit_hash}", + "description": f"Latest commit by {description}", + "source_code_management_uri": f"{repo_url}", + } + + engagement = await dd.create_engagement( + name=engagement_data["name"], + product_id=engagement_data["product_id"], + lead_id=engagement_data["lead_id"], + status=engagement_data["status"], + target_start=engagement_data["target_start"], + target_end=engagement_data["target_end"], + engagement_type=engagement_data["engagement_type"], + deduplication_on_engagement=engagement_data["deduplication_on_engagement"], + build_id=engagement_data["build_id"], + commit_hash=engagement_data["commit_hash"], + description=engagement_data["description"], + source_code_management_uri=engagement_data["source_code_management_uri"], + ) + engagement = handle_dd_response(engagement, name) + engagement_name = engagement["name"] + engagement_id = engagement["id"] + logger.info(f"[x] Engagement was created: {engagement_name} #{engagement_id}") + logger.info(f"[x] Check product at {credentials.url}/product/{product_id}") + logger.info( + f"[x] Check engagement at {credentials.url}/engagement/{engagement_id}" + ) + return engagement_id + + +async def dd_upload( + credentials: DefectDojoCredentials, + engagement_id, + scan_type, + report_file, + tag: str, + minimum_severity="High", +): + dd = defectdojo.DefectDojoAPIv2( + credentials.url, + credentials.secret_key, + credentials.user, + debug=False, + timeout=360, + ) + # scan_type - e.g. Nuclei Scan + valid_scan_type = WORKER_TO_SCAN_TYPE_MAPPER.get(scan_type, scan_type) + upload_data = { + "engagement_id": f"{engagement_id}", + "scan_type": f"{valid_scan_type}", + "file": f"{report_file}", + "active": True, + "verified": False, + "close_old_findings": False, + "skip_duplicates": False, + "scan_date": f'{date.today().strftime("%Y-%m-%d")}', + "minimum_severity": f"{minimum_severity}", + } + upload = await dd.upload_scan( + engagement_id=upload_data["engagement_id"], + scan_type=upload_data["scan_type"], + file=upload_data["file"], + active=upload_data["active"], + verified=upload_data["verified"], + close_old_findings=upload_data["close_old_findings"], + skip_duplicates=upload_data["skip_duplicates"], + scan_date=upload_data["scan_date"], + minimum_severity=upload_data["minimum_severity"], + tags=tag, # list of tags, but we will use only commit hash id + ) + if not upload.success: + raise RuntimeError(upload.data) + return upload + + +async def dd_findings_by_test(credentials: DefectDojoCredentials, test_id: int): + dd = defectdojo.DefectDojoAPIv2( + credentials.url, + credentials.secret_key, + credentials.user, + debug=False, + timeout=360, + ) + findings = await dd.list_findings( + active="true", + duplicate="false", + test_id_in=[test_id], + # NOTE(ivan.zhirov): Temporary solution before the pagination system + # will be added + # TODO(ivan.zhirov): Implement proper pagination + limit=500, + ) + return handle_dd_response(findings, str(test_id)) + + +async def dd_get_test( + credentials: DefectDojoCredentials, + test_id: int, +): + dd = defectdojo.DefectDojoAPIv2( + credentials.url, + credentials.secret_key, + credentials.user, + debug=False, + timeout=360, + ) + test = await dd.get_test(test_id) + test = handle_dd_response(test, str(test_id)) + return test + + +async def send_result( + credentials: DefectDojoCredentials, + output_result: OutputResultObject, +) -> Tuple[int, List[OutputFinding]]: + web_url = output_result.data.project.web_url + product_type = urlparse(web_url).hostname + product_name = output_result.data.project.path_with_namespace + commit_hash = output_result.data.commit.id + eng_id = await dd_prepare( + credentials, + product_type=product_type, + product_name=product_name, + product_description=web_url, + repo_url=output_result.data.commit.url.replace("/-/commit/", "/-/blob/"), + name=yarl.URL(output_result.data.path).path, + commit_hash=commit_hash, + description=output_result.data.commit.author.email, + ) + with tempfile.NamedTemporaryFile(prefix="dd_output_") as tmp_file: + with open(tmp_file.name, "wb") as tmp_file_write: + tmp_file_write.write(output_result.result.encode()) + + test_upload = await dd_upload( + credentials, + engagement_id=eng_id, + scan_type=output_result.worker, + report_file=tmp_file.name, + tag=commit_hash, + ) + test_upload_id = test_upload.data["test_id"] + for i in range(30): + test = await dd_get_test(credentials, test_upload_id) + if test["percent_complete"] == 100: + break + await asyncio.sleep(10) + else: + raise RuntimeError( + f"Took too much time to handle the output, test_id={test_upload_id}" + ) + + await asyncio.sleep(120) # wait for deduplication + + response = await dd_findings_by_test(credentials, test_upload_id) + findings = [ + OutputFinding( + # todo: do smth with types + title=finding["title"], + severity=Severity(finding["severity"]), + url=str( + yarl.URL(credentials.url).with_path(f"finding/{str(finding['id'])}") + ), + ) + for finding in response["results"] + ] + return test_upload_id, findings diff --git a/app/secbot/inputs/gitlab/handlers/defectdojo/validator.py b/app/secbot/inputs/gitlab/handlers/defectdojo/validator.py new file mode 100755 index 0000000..4910bb4 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/defectdojo/validator.py @@ -0,0 +1,141 @@ +from typing import Any, Dict, List, Optional, TypeVar + +from pydantic import BaseModel + +import app.secbot.inputs.gitlab.handlers.defectdojo.api as defectdojo +from app.secbot.config import SecbotConfigComponent +from app.secbot.inputs.gitlab.handlers.defectdojo.services import ( + DefectDojoCredentials, + handle_dd_response, +) +from app.secbot.inputs.gitlab.schemas.base import CommitHash +from app.secbot.schemas import Severity + +Findings = TypeVar("Findings", bound=List[Dict[Any, Any]]) + + +class DefectDojoFindingDuplicate(BaseModel): + active: bool + severity: Severity + + +class DefectDojoFindings(BaseModel): + scan_name: str + active: bool + severity: Severity + duplicate: Optional[DefectDojoFindingDuplicate] = None + + @property + def is_active(self) -> bool: + """Check if the finding is active. + + This method returns whether the finding is considered active or not. + If the finding has a duplicate attribute, + the method returns the active attribute of the duplicate object. + """ + if self.duplicate: + return self.duplicate.active + return self.active + + +def is_gitleaks_valid(findings: List[DefectDojoFindings]) -> bool: + """Check if the findings from Gitleaks are valid. + + This function checks if the findings from the Gitleaks scan service are valid. + + If all findings are inactive the function returns True. + """ + assert all(finding.scan_name == "gitleaks" for finding in findings) + for finding in findings: + if finding.is_active: + return False + return True + + +class DefectDojoFindingsValidator: + """Validator for DefectDojo findings. + + Based on findings from specific commit hash and by provided validators + """ + + class Meta: + validators = { + "gitleaks": is_gitleaks_valid, + } + scan_type_name = { + "Gitleaks Scan": "gitleaks", + } + + def __init__( + self, + eligible_scans: List[SecbotConfigComponent], + credentials: DefectDojoCredentials, + commit_hash: CommitHash, + ): + self.eligible_scans = eligible_scans + self.commit_hash = commit_hash + self.credentials = credentials + + async def _fetch_findings(self): + dd = defectdojo.DefectDojoAPIv2( + self.credentials.url, + self.credentials.secret_key, + self.credentials.user, + debug=False, + timeout=360, + ) + response = await dd.list_findings( + # NOTE(iz): We send commit_hash as a test tag to all scans + # by this param we filter results and get all findings + # based on specific security check + test_tags=[self.commit_hash], + related_fields=True, + prefetch=["duplicate_finding"], + # NOTE(ivan.zhirov): Temporary solution before the pagination system + # will be added + # TODO(ivan.zhirov): Implement proper pagination + limit=500, + ) + response = handle_dd_response(response) + duplicates = response["prefetch"].get("duplicate_finding", {}) + for finding in response["results"]: + duplicate_finding = None + if duplicate_finding_id := finding.get("duplicate_finding"): + duplicate_dict = duplicates[str(duplicate_finding_id)] + duplicate_finding = DefectDojoFindingDuplicate( + active=duplicate_dict["active"], + severity=Severity(duplicate_dict["severity"]), + ) + yield DefectDojoFindings( + severity=finding["severity"], + duplicate=duplicate_finding, + active=finding["active"], + scan_name=self.Meta.scan_type_name[ + finding["related_fields"]["test"]["test_type"]["name"] + ], + ) + + async def is_valid(self) -> bool: + """Check if the current instance of the class is valid. + + This function checks if all the findings from the scan services are valid + by using the validators specified in the validators attribute. + """ + all_findings = [finding async for finding in self._fetch_findings()] + eligible_scan_handler_names = [ + scan.handler_name for scan in self.eligible_scans + ] + validators = { + check_service: validator + for check_service, validator in self.Meta.validators.items() + if check_service in eligible_scan_handler_names + } + for check_service, validator in validators.items(): + findings = [ + finding + for finding in all_findings + if finding.scan_name == check_service + ] + if not validator(findings): + return False + return True diff --git a/app/secbot/inputs/gitlab/handlers/gitleaks/__init__.py b/app/secbot/inputs/gitlab/handlers/gitleaks/__init__.py new file mode 100755 index 0000000..c0db39d --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/gitleaks/__init__.py @@ -0,0 +1,107 @@ +import json +import subprocess +import tempfile + +from sqlalchemy import update + +from app.secbot.db import db_session +from app.secbot.exceptions import ScanCheckFailed +from app.secbot.handlers import SecbotScanHandler +from app.secbot.inputs.gitlab import RepositorySecurityScan +from app.secbot.inputs.gitlab.schemas import ( + GitlabInputData, + GitlabScanResult, + GitlabScanResultFile, +) +from app.secbot.inputs.gitlab.services import ( + clone_repository, + handle_exception, + start_scan, +) +from app.secbot.schemas import SecbotBaseModel + + +class GitleaksConfig(SecbotBaseModel): + format: str = "json" + + +class GitleaksHandler(SecbotScanHandler): + config_model = GitleaksConfig + + async def on_failure( + self, + input_data: GitlabInputData, + exception, + component_name: str, + config: GitleaksConfig, + ) -> None: + await handle_exception( + check_id=input_data.db_check_id, + scan_component_name=component_name, + exception=exception, + ) + + async def run( + self, + input_data: GitlabInputData, + component_name: str, + config: GitleaksConfig, + ) -> GitlabScanResult: + # Create and start the gitleaks scan object + scan = await start_scan(component_name, input_data.db_check_id) + + # Clone the entire repository and save it in the temporary directory + with clone_repository( + repository_url=input_data.data.project.git_http_url, + reference=input_data.data.commit.id, + ) as repository_temp_path: + + # Create a temporary file and save the result of the check in it + with tempfile.NamedTemporaryFile(prefix="secbot-gitleaks-") as temp_file: + try: + subprocess.run( + [ + "gitleaks", + "detect", + "--redact", + "-f", + config.format, + "-r", + temp_file.name, + ], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + universal_newlines=True, + cwd=repository_temp_path, + check=False, + ) + except RuntimeError: + raise ScanCheckFailed() + + # Read the content of the temporary file with scan defects + # and save it in the database + with open(temp_file.name, "rb") as output_file: + content = output_file.read() + response = json.loads(content.decode()) + + async with db_session() as session: + await session.execute( + update(RepositorySecurityScan) + .where(RepositorySecurityScan.id == scan.id) + .values(response=response) + ) + await session.commit() + + scan_file = GitlabScanResultFile( + commit_hash=input_data.data.commit.id, + scan_name=self.config_name, + format=config.format, + content=response, + ) + return GitlabScanResult( + db_id=scan.id, + input=input_data, + handler_name=self.config_name, + component_name=component_name, + file=scan_file, + ) diff --git a/app/secbot/inputs/gitlab/handlers/slack/__init__.py b/app/secbot/inputs/gitlab/handlers/slack/__init__.py new file mode 100755 index 0000000..5446b24 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/slack/__init__.py @@ -0,0 +1,85 @@ +from typing import List + +from sqlalchemy import select + +from app.secbot.db import db_session +from app.secbot.handlers import SecbotNotificationHandler +from app.secbot.inputs.gitlab.handlers.slack.api import send_message +from app.secbot.inputs.gitlab.handlers.slack.utils import generate_message_blocks +from app.secbot.inputs.gitlab.models import SlackNotifications +from app.secbot.inputs.gitlab.schemas import GitlabOutputResult +from app.secbot.inputs.gitlab.services import handle_exception +from app.secbot.schemas import SecbotBaseModel + + +class SlackCredentials(SecbotBaseModel): + token: str + + +class SlackConfig(SecbotBaseModel): + render_limit: int + channels: List[str] + + +class SlackHandler(SecbotNotificationHandler): + config_name = "slack" + config_model = SlackConfig + env_model = SlackCredentials + + async def on_failure( + self, + output: GitlabOutputResult, + exception, + component_name: str, + config: SlackConfig, + env: SlackCredentials, + ): + await handle_exception( + check_id=output.scan_result.input.db_check_id, + scan_component_name=output.scan_result.component_name, + exception=exception, + ) + + async def run( + self, + output: GitlabOutputResult, + component_name: str, + config: SlackConfig, + env: SlackCredentials, + ): + """Send notification to slack channel.""" + message_blocks = generate_message_blocks( + output=output, + render_limit=config.render_limit, + ) + if not message_blocks: + return + + for channel in config.channels: + async with db_session() as session: + notification = ( + await session.execute( + select(SlackNotifications) + .with_for_update() + .where( + SlackNotifications.scan_id == output.scan_result.db_id, + SlackNotifications.channel == channel, + ) + ) + ).scalar() + if notification and notification.is_sent is True: + return + if not notification: + notification = SlackNotifications( + scan_id=output.scan_result.db_id, + channel=channel, + payload=message_blocks, + ) + await send_message( + channel=channel, + payload=notification.payload, + token=env.token, + ) + notification.is_sent = True + session.add(notification) + await session.commit() diff --git a/app/secbot/inputs/gitlab/handlers/slack/api.py b/app/secbot/inputs/gitlab/handlers/slack/api.py new file mode 100755 index 0000000..42d8b87 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/slack/api.py @@ -0,0 +1,15 @@ +from slack_sdk.web.async_client import AsyncWebClient + + +async def send_message( + token: str, + channel: str, + payload: dict, +) -> None: + """Send message payload to the specific channel via a secbot app.""" + assert token, "The token is missing." + assert channel, "The channel name is missing." + assert payload, "The payload can't be empty." + + client = AsyncWebClient(token=token) + await client.chat_postMessage(channel=channel, blocks=payload) diff --git a/app/secbot/inputs/gitlab/handlers/slack/utils.py b/app/secbot/inputs/gitlab/handlers/slack/utils.py new file mode 100755 index 0000000..6ce5eb3 --- /dev/null +++ b/app/secbot/inputs/gitlab/handlers/slack/utils.py @@ -0,0 +1,57 @@ +from typing import Dict, List, Optional + +from app.secbot.inputs.gitlab.schemas import GitlabOutputResult +from app.secbot.schemas import Severity + +SEVERITY_TO_EMOJI: Dict[Severity, str] = { + Severity.INFO: ":white_circle:", + Severity.LOW: ":large_green_circle:", + Severity.MEDIUM: ":large_yellow_circle:", + Severity.HIGH: ":large_orange_circle:", + Severity.CRITICAL: ":red_circle:", +} + + +def generate_message_blocks( + output: GitlabOutputResult, + render_limit: int, +) -> Optional[List[Dict[str, str]]]: + + new_findings_count = len(output.response.findings) + if new_findings_count == 0: + return None + + message_blocks = [] + + def add_to_message_blocks(msg: str) -> None: + nonlocal message_blocks + + block = {"type": "section", "text": {"type": "mrkdwn", "text": msg}} + message_blocks.append(block) + + # Message header + project = output.response.project_name + project_url = output.response.project_url + message = f"Worker *{output.scan_result.component_name}* found *{new_findings_count}* new findings in *<{project_url}|{project}>*:" + add_to_message_blocks(message) + + # Sort findings by severity and limit them + findings = sorted( + output.response.findings[:render_limit], + key=lambda item: item.severity.priority, + ) + + # Add limited findings info text blocks + for finding in findings: + finding_severity = SEVERITY_TO_EMOJI.get( + finding.severity, ":large_purple_circle:" + ) + message = f"{finding_severity} <{finding.url}|{finding.title}>" + add_to_message_blocks(message) + + # Add special info message block if findings count is greater than limit + if new_findings_count > render_limit: + message = f":no_bell: *{new_findings_count - render_limit}* were *stripped* from notification :no_bell:" + add_to_message_blocks(message) + + return message_blocks diff --git a/app/secbot/inputs/gitlab/models.py b/app/secbot/inputs/gitlab/models.py new file mode 100755 index 0000000..bad3125 --- /dev/null +++ b/app/secbot/inputs/gitlab/models.py @@ -0,0 +1,80 @@ +from sqlalchemy import Boolean, Column, DateTime, Enum, ForeignKey, Integer, String +from sqlalchemy.dialects.postgresql import JSON +from sqlalchemy.orm import relationship + +from app.secbot.db import Base +from app.secbot.inputs.gitlab.schemas import GitlabEvent +from app.secbot.schemas import ScanStatus + + +class RepositorySecurityCheck(Base): + """The base model of GitLab repository check. + + Each GitLab event should have only one RepositorySecurityCheck. + """ + + __tablename__ = "repository_security_check" + + id = Column(Integer(), primary_key=True, autoincrement=True) + external_id = Column(String, nullable=False, unique=True) + + event_type = Column(Enum(GitlabEvent), nullable=False) + event_json = Column(JSON, nullable=False) + + commit_hash = Column(String, nullable=False) + branch = Column(String, nullable=False) + project_name = Column(String, nullable=False) + path = Column(String, nullable=False) + prefix = Column(String, nullable=False) + + scans = relationship("RepositorySecurityScan", lazy=True) + + +class RepositorySecurityScan(Base): + """The base model of a particular service scan of repository security check. + + Each service should have only one scan within the one check. + """ + + __tablename__ = "repository_security_scan" + + check_id = Column( + Integer, + ForeignKey("repository_security_check.id"), + nullable=False, + ) + + id = Column(Integer, primary_key=True, autoincrement=True) + + started_at = Column(DateTime, nullable=True) + finished_at = Column(DateTime, nullable=True) + + status = Column(Enum(ScanStatus), nullable=False, default=ScanStatus.NEW) + response = Column(JSON, nullable=True) + + # Config name of the scan + scan_name = Column(String, nullable=False) + + # Map to outputs and test id in third party services + # e.g. + # {"defectdojo": 42, "other": "test-123"} + outputs_test_id = Column(JSON) + + slack_notification = relationship("SlackNotifications", lazy=True, uselist=False) + + +class SlackNotifications(Base): + """State of scan notification to the Slack channel""" + + __tablename__ = "slack_notifications" + + id = Column(Integer(), primary_key=True, autoincrement=True) + channel = Column(String, nullable=False) + is_sent = Column(Boolean, default=False) + payload = Column(JSON, nullable=False) + + scan_id = Column( + Integer, + ForeignKey("repository_security_scan.id"), + nullable=False, + ) diff --git a/app/secbot/inputs/gitlab/schemas/__init__.py b/app/secbot/inputs/gitlab/schemas/__init__.py new file mode 100755 index 0000000..3d19102 --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/__init__.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +from typing import Any, Dict, List, NewType, Type, Union + +from app.secbot.inputs.gitlab.schemas.base import GitlabEvent +from app.secbot.inputs.gitlab.schemas.merge_request import MergeRequestWebhookModel +from app.secbot.inputs.gitlab.schemas.output_responses import OutputResponse +from app.secbot.inputs.gitlab.schemas.push import PushWebhookModel +from app.secbot.inputs.gitlab.schemas.tag import TagWebhookModel +from app.secbot.schemas import SecbotBaseModel + +# A generated hash string of GitLab event. +# To reference, look at the `generate_gitlab_security_id` method. +GitlabWebhookSecurityID = NewType("GitlabWebhookSecurityID", str) + +# Common type for all GitLab models. +AnyGitlabModel = Union[MergeRequestWebhookModel, PushWebhookModel, TagWebhookModel] + +# Map of GitLab events to models. +GITLAB_EVENTS_MAP: Dict[GitlabEvent, Type[AnyGitlabModel]] = { + GitlabEvent.PUSH: PushWebhookModel, + GitlabEvent.TAG_PUSH: TagWebhookModel, + GitlabEvent.MERGE_REQUEST: MergeRequestWebhookModel, +} + + +def get_gitlab_model_for_event(event: GitlabEvent, data: dict) -> AnyGitlabModel: + """Get the GitLab model for the given event.""" + model = GITLAB_EVENTS_MAP[event] + return model(**data, raw=data) + + +class GitlabInputData(SecbotBaseModel): + """Input model for GitLab events.""" + + db_check_id: int + event: GitlabEvent + data: AnyGitlabModel + + +class GitlabScanResultFile(SecbotBaseModel): + """Scan result file data for GitLab events.""" + + commit_hash: str + scan_name: str + format: str + content: Union[Dict[str, Any], List[Dict[str, Any]]] + + @property + def filename(self) -> str: + return f"{self.commit_hash}_gitlab_{self.scan_name}.{self.format}" + + +class GitlabScanResult(SecbotBaseModel): + """Scan result model for GitLab events.""" + + db_id: int + handler_name: str + component_name: str + input: GitlabInputData + file: GitlabScanResultFile + + +class GitlabOutputResult(SecbotBaseModel): + """Output result model for GitLab events.""" + + component_name: str + handler_name: str + scan_result: GitlabScanResult + response: OutputResponse diff --git a/app/secbot/inputs/gitlab/schemas/base.py b/app/secbot/inputs/gitlab/schemas/base.py new file mode 100755 index 0000000..a6ae8db --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/base.py @@ -0,0 +1,67 @@ +import abc +import enum +from datetime import datetime + +from pydantic import AnyUrl, BaseModel + +CommitHash = str + + +class Repository(BaseModel): + name: str + url: str + homepage: AnyUrl + + +class Author(BaseModel): + name: str + email: str + + +class Project(BaseModel): + id: int + name: str + web_url: AnyUrl + git_ssh_url: str + git_http_url: AnyUrl + namespace: str + path_with_namespace: str + + +class Commit(BaseModel): + id: CommitHash + message: str + timestamp: datetime + url: AnyUrl + author: Author + + +class GitlabEvent(str, enum.Enum): + PUSH = "Push Hook" + TAG_PUSH = "Tag Push Hook" + MERGE_REQUEST = "Merge Request Hook" + + +class BaseGitlabEventData(BaseModel, abc.ABC): + project: Project + repository: Repository + raw: dict + + @property + @abc.abstractmethod + def target_branch(self) -> str: + raise NotImplementedError() + + @property + @abc.abstractmethod + def commit(self) -> Commit: + raise NotImplementedError() + + @property + @abc.abstractmethod + def path(self) -> str: + raise NotImplementedError() + + @property + def team_name(self) -> str: + return self.repository.homepage.path[1:] diff --git a/app/secbot/inputs/gitlab/schemas/merge_request.py b/app/secbot/inputs/gitlab/schemas/merge_request.py new file mode 100755 index 0000000..0cfbafd --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/merge_request.py @@ -0,0 +1,44 @@ +from __future__ import annotations + +from enum import Enum +from typing import Optional + +from pydantic import AnyUrl, BaseModel + +from app.secbot.inputs.gitlab.schemas.base import BaseGitlabEventData, Commit + + +class MergeRequestAction(str, Enum): + open = "open" + close = "close" + reopen = "reopen" + update = "update" + approved = "approved" + unapproved = "unapproved" + merge = "merge" + + +class MergeRequestObjectAttributes(BaseModel): + id: int + url: AnyUrl + state: str + target_branch: str + source_branch: str + action: Optional[MergeRequestAction] + last_commit: Commit + + +class MergeRequestWebhookModel(BaseGitlabEventData): + object_attributes: MergeRequestObjectAttributes + + @property + def commit(self) -> Commit: + return self.object_attributes.last_commit + + @property + def path(self) -> str: + return self.object_attributes.url + + @property + def target_branch(self) -> str: + return self.object_attributes.target_branch diff --git a/app/secbot/inputs/gitlab/schemas/output_responses.py b/app/secbot/inputs/gitlab/schemas/output_responses.py new file mode 100755 index 0000000..5d595aa --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/output_responses.py @@ -0,0 +1,21 @@ +from typing import List + +from pydantic import AnyUrl, BaseModel + +from app.secbot.schemas import Severity + + +class OutputFinding(BaseModel): + """Base output finding model.""" + + title: str + severity: Severity + url: AnyUrl + + +class OutputResponse(BaseModel): + """Base output response model.""" + + project_name: str + project_url: AnyUrl + findings: List[OutputFinding] diff --git a/app/secbot/inputs/gitlab/schemas/push.py b/app/secbot/inputs/gitlab/schemas/push.py new file mode 100755 index 0000000..9fe9f88 --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/push.py @@ -0,0 +1,28 @@ +from typing import List + +from app.secbot.inputs.gitlab.schemas.base import ( + BaseGitlabEventData, + Commit, + CommitHash, +) + + +class PushWebhookModel(BaseGitlabEventData): + after: CommitHash + ref: str + commits: List[Commit] + + @property + def path(self) -> str: + return self.commit.url + + @property + def target_branch(self) -> str: + assert "heads" in self.ref + + parts = self.ref.split("/") + return parts[-1] + + @property + def commit(self) -> Commit: + return next(commit for commit in self.commits if commit.id == self.after) diff --git a/app/secbot/inputs/gitlab/schemas/tag.py b/app/secbot/inputs/gitlab/schemas/tag.py new file mode 100755 index 0000000..ce569bc --- /dev/null +++ b/app/secbot/inputs/gitlab/schemas/tag.py @@ -0,0 +1,32 @@ +from typing import List + +from app.secbot.inputs.gitlab.schemas.base import ( + BaseGitlabEventData, + Commit, + CommitHash, +) + + +class TagWebhookModel(BaseGitlabEventData): + checkout_sha: CommitHash + ref: str + commits: List[Commit] + + @property + def path(self) -> str: + return self.commit.url + + @property + def target_branch(self) -> str: + assert "tags" in self.ref + + parts = self.ref.split("/") + return parts[-1] + + @property + def commit(self) -> Commit: + return next( + event_commit + for event_commit in self.commits + if event_commit.id == self.checkout_sha + ) diff --git a/app/secbot/inputs/gitlab/services.py b/app/secbot/inputs/gitlab/services.py new file mode 100755 index 0000000..0904526 --- /dev/null +++ b/app/secbot/inputs/gitlab/services.py @@ -0,0 +1,310 @@ +import tempfile +from contextlib import contextmanager +from datetime import datetime +from typing import Dict, Optional, Union, cast +from urllib.parse import urlparse + +import git +import requests +import yarl +from sqlalchemy import and_, select +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import async_scoped_session + +from app.secbot.db import db_session as async_db_session +from app.secbot.exceptions import ScanCantBeScanned, ScanExecutionSkipped +from app.secbot.inputs.gitlab.models import ( + RepositorySecurityCheck, + RepositorySecurityScan, +) +from app.secbot.inputs.gitlab.schemas import GitlabWebhookSecurityID +from app.secbot.inputs.gitlab.schemas.base import Project +from app.secbot.inputs.gitlab.utils import get_config_from_host +from app.secbot.logger import logger +from app.secbot.schemas import ScanStatus + + +@contextmanager +def clone_repository( + repository_url: str, + reference: str = "main", +): + """ + Clone a Git repository to a temporary directory and checkout to a specific reference. + + This context manager clones a Git repository specified by its URL into a temporary + directory, checks out to a certain reference (default to 'main'), and then cleans + up the directory once done. + + Args: + repository_url (str): The URL of the Git repository to clone. + reference (str, optional): The Git reference to checkout. Defaults to 'main'. + + Yields: + str: The path to the temporary directory where the repository was cloned. + + Raises: + AssertionError: If the hostname can't be parsed from the repository URL. + """ + host = urlparse(repository_url).hostname + assert host + + with tempfile.TemporaryDirectory() as temp_directory: + user = "oauth2" + token = get_config_from_host(host).auth_token.get_secret_value() + + repository_url = str( + yarl.URL(repository_url).with_user(user).with_password(token) + ) + repo = git.Repo.clone_from(repository_url, temp_directory) + repo.git.checkout(reference) + yield temp_directory + + +def get_gitlab_project_languages(project: Project) -> Optional[Dict[str, float]]: + """ + Returns the dictionary with languages for the project or None if it was not possible to get it + Example dict: {'Python': 75.06, 'Makefile': 11.11, 'Dockerfile': 7.95, 'Shell': 5.87} + """ + host = urlparse(project.web_url).hostname + assert host + + token = get_config_from_host(host).auth_token.get_secret_value() + api_url = yarl.URL(project.web_url).with_path( + f"/api/v4/projects/{project.id}/languages" + ) + # TODO(ivan.zhirov): make it async + response = requests.get( + url=str(api_url), + headers={"PRIVATE-TOKEN": token}, + ) + if response.status_code != 200: + return None + return cast(Dict[str, float], response.json()) + + +# TODO(ivan.zhirov): add tests +async def get_or_create_security_check( + db_session: async_scoped_session, + external_id: GitlabWebhookSecurityID, + initial_data: Optional[dict] = None, +) -> RepositorySecurityCheck: + """Retrieve or create a new RepositorySecurityCheck entry. + + Args: + db_session (async_scoped_session): The database session to use for the operation. + external_id (GitlabWebhookSecurityID): The external ID to search for. + initial_data (Optional[dict], optional): The data to use if creating a new entry. + Defaults to None, in which case an empty dict is used. + + Returns: + RepositorySecurityCheck: The retrieved or newly created RepositorySecurityCheck entry. + """ + + async def get_security_check() -> RepositorySecurityCheck: + return ( + await db_session.execute( + select(RepositorySecurityCheck).where( + RepositorySecurityCheck.external_id == external_id, + ) + ) + ).scalar() + + security_check = await get_security_check() + try: + if not security_check: + initial_data = initial_data or {} + security_check = RepositorySecurityCheck( + external_id=external_id, + **initial_data, + ) + db_session.add(security_check) + await db_session.commit() + except IntegrityError: + security_check = await get_security_check() + return security_check + + +# TODO(ivan.zhirov): add tests +async def get_or_create_security_scan( + db_session: async_scoped_session, + check_id: int, + scan_name: str, +) -> RepositorySecurityScan: + """Retrieve or create a new RepositorySecurityScan entry. + + Args: + db_session (async_scoped_session): The database session to use for the operation. + check_id (int): The check ID to search for. + scan_name (str): The scan name to search for. + + Returns: + RepositorySecurityScan: The retrieved or newly created RepositorySecurityScan entry. + """ + + async def get_scan() -> RepositorySecurityScan: + return ( + await db_session.execute( + select(RepositorySecurityScan).where( + and_( + RepositorySecurityScan.check_id == check_id, + RepositorySecurityScan.scan_name == scan_name, + ) + ) + ) + ).scalar() + + scan = await get_scan() + try: + if not scan: + scan = RepositorySecurityScan( + check_id=check_id, + scan_name=scan_name, + ) + db_session.add(scan) + await db_session.commit() + except IntegrityError: + scan = await get_scan() + return scan + + +async def start_scan(scan_name: str, check_id: int) -> RepositorySecurityScan: + """Initiate a security scan and update its status to 'IN_PROGRESS'. + + This asynchronous function starts a security scan by first fetching or creating + a RepositorySecurityScan entry via the get_or_create_security_scan() function. + It then checks the current status of the scan. If the status is neither 'NEW' nor + 'ERROR', an exception (ScanCantBeScanned) is raised, preventing the scan from starting. + If the status is either 'NEW' or 'ERROR', the function updates the status of the scan + to 'IN_PROGRESS', sets the start time to the current datetime, commits these changes + to the database, and finally returns the RepositorySecurityScan entry. + + Args: + scan_name (str): The name of the scan. + check_id (int): The ID of the check for the scan. + + Returns: + RepositorySecurityScan: The updated RepositorySecurityScan entry. + + Raises: + ScanCantBeScanned: If the status of the scan is not 'NEW' or 'ERROR'. + """ + async with async_db_session() as session: + scan = await get_or_create_security_scan( + db_session=session, + check_id=check_id, + scan_name=scan_name, + ) + if scan.status not in [ScanStatus.NEW, ScanStatus.ERROR]: + raise ScanCantBeScanned( + f"Scan can't be scanned: reason={scan.status}", + scan.id, + ) + + # Update the scan status to In progress + scan.status = ScanStatus.IN_PROGRESS + scan.started_at = datetime.now() + + session.add(scan) + await session.commit() + + return scan + + +async def complete_scan( + *, + scan_id: int, + output_component_name: str, + output_external_test_id: Union[str, int], +): + """Mark a security scan as complete and update related information. + + This function is used to mark a specific security scan as completed (DONE). + It first retrieves the specific RepositorySecurityScan instance from the + database using the provided scan_id. It then updates the scan's + 'outputs_test_id' field by appending the output_external_test_id associated + with the output_component_name. The scan status is then set to 'DONE', and the + completion time is recorded as the current datetime. These updates are then + committed to the database. + + Args: + scan_id (int): The ID of the scan to be completed. + output_component_name (str): The name of the output component related to the scan. + output_external_test_id (Union[str, int]): The external test ID related to the output component. + + Raises: + AssertionError: If the scan with the provided scan_id does not exist. + """ + + async with async_db_session() as session: + scan = ( + await session.execute( + select(RepositorySecurityScan).where( + RepositorySecurityScan.id == scan_id + ) + ) + ).scalar() + assert scan is not None, "Scan id is not defined" + + scan.outputs_test_id = { + **(scan.outputs_test_id or {}), + output_component_name: output_external_test_id, + } + scan.status = ScanStatus.DONE + scan.finished_at = datetime.now() + await session.commit() + + +async def handle_exception( + *, + check_id: int, + scan_component_name: str, + exception: Exception, +): + """Handle an exception that occurred during a security scan. + + This asynchronous function is designed to handle exceptions that occur + during a security check. It updates the status of the current scan in the database + according to the type of exception that occurred. If the scan cannot be found, + it logs a warning and re-raises the exception. + + If the exception is of type ScanExecutionSkipped, the scan status is updated to 'SKIP'. + For any other type of exception, the scan status is set to 'ERROR'. + + Args: + check_id (int): The ID of the security check associated with the scan. + scan_component_name (str): The name of the scan component where the exception occurred. + exception (Exception): The exception that occurred. + + Raises: + Exception: If the scan associated with the provided + check_id and scan_component_name does not exist in the database, + the function re-raises the passed exception. + """ + async with async_db_session() as session: + # Getting the current handler scan + scan = ( + await session.execute( + select(RepositorySecurityScan).where( + and_( + RepositorySecurityScan.check_id == check_id, + RepositorySecurityScan.scan_name == scan_component_name, + ) + ) + ) + ).scalar() + + # In case we failed even before the scan has been created + # We just log the error and re-raise the exception + if not scan: + logger.warning("Scan id is not defined") + raise exception + + if isinstance(exception, ScanExecutionSkipped): + # We mark the scan as skipped in order that scan has been failed + # but in good way (e.g. we don't support the language). + # Later, the scan will be not be used in result checks. + scan.status = ScanStatus.SKIP + else: + scan.status = ScanStatus.ERROR + await session.commit() diff --git a/app/secbot/inputs/gitlab/utils.py b/app/secbot/inputs/gitlab/utils.py new file mode 100755 index 0000000..e17a5c6 --- /dev/null +++ b/app/secbot/inputs/gitlab/utils.py @@ -0,0 +1,88 @@ +from hashlib import sha256 +from pathlib import Path + +import yarl + +from app.secbot.inputs.gitlab.schemas import AnyGitlabModel, GitlabWebhookSecurityID +from app.settings import GitlabConfig, settings + + +def get_project_name(git_ssh_url: str) -> str: + """Get project name from git ssh url.""" + project = git_ssh_url + if project.startswith("git@"): + project = project[4:] + if project.endswith(".git"): + project = project[:-4] + return project + + +def generate_gitlab_security_id( + prefix: str, + data: AnyGitlabModel, +) -> GitlabWebhookSecurityID: + """Generate hash of gitlab webhook event. + + The algorithm is a string with the formation of git prefix + (since we have not only one GitLab) + and sha256 of project path and complete commit hash. + """ + project_path = get_project_name(data.project.git_ssh_url) + hash_str = f"{project_path}_{data.commit.id}" + return GitlabWebhookSecurityID(f"{prefix}_{sha256(hash_str.encode()).hexdigest()}") + + +def override_git_credentials(): + """Overrides Git credentials using configurations from the settings. + + This function creates/overwrites a '.git-credentials' file at the user's home directory. + The file includes the hosts from GitLab configurations in the settings, each paired with + an 'oauth2' user and a corresponding authentication token. + + Returns: + A file object representing the '.git-credentials' file. + + Raises: + Exception: Any exception that occurs while writing to the file. + """ + user = "oauth2" + git_credentials_path = Path.home() / ".git-credentials" + git_credentials_file = open(git_credentials_path, "w") + + try: + git_credentials_content = "\n".join( + [ + str( + yarl.URL(config.host) + .with_user(user) + .with_password(config.auth_token.get_secret_value()) + ) + for config in settings.gitlab_configs + ] + ) + git_credentials_file.write(git_credentials_content) + + return git_credentials_file + finally: + git_credentials_file.close() + + +def get_config_from_host(host: str) -> GitlabConfig: + """ + Retrieves a GitLab configuration that matches a specified host. + + This function iterates over all GitLab configurations in the settings. It returns + the first configuration whose host matches the provided host string. + + Args: + host (str): The host to match against GitLab configurations. + + Returns: + GitlabConfig: The GitLab configuration that matches the provided host. + + Raises: + StopIteration: If no configuration matches the provided host. + """ + return next( + config for config in settings.gitlab_configs if config.host.host == host + ) diff --git a/app/secbot/logger.py b/app/secbot/logger.py new file mode 100755 index 0000000..5fd3c59 --- /dev/null +++ b/app/secbot/logger.py @@ -0,0 +1,4 @@ +import logging + +logger = logging.getLogger("secbot") +logger.setLevel(logging.INFO) diff --git a/app/secbot/schemas.py b/app/secbot/schemas.py new file mode 100755 index 0000000..09a7577 --- /dev/null +++ b/app/secbot/schemas.py @@ -0,0 +1,77 @@ +import enum + +from pydantic import BaseModel, root_validator + +PYDANTIC_CLS_PATH = "__pydantic_path_model__" + + +class SecbotBaseModel(BaseModel): + """Base model for Secbot, supporting serialization/deserialization. + + This class extends the Pydantic BaseModel for use in Secbot's Celery + workflow where models need to be serialized and deserialized. + + It ensures the inclusion of an absolute path to the class model in each + instance, which is used later for deserialization. + """ + + @root_validator + def populate_with_class_model(cls, values): + """Populates the model with the absolute class model path. + + As a Pydantic root validator, it's invoked during validation for + each model instance. It takes the model's attribute mapping, and + adds a new entry under the `PYDANTIC_CLS_PATH` key. This path + includes the module and class name, used later for deserialization. + + Args: + values (dict): Model's attribute mapping. + + Returns: + The updated attribute mapping. + """ + values[PYDANTIC_CLS_PATH] = f"{cls.__module__}.{cls.__name__}" + return values + + +class Severity(str, enum.Enum): + # NOTE(ivan.zhirov): These severities are from defectdojo statuses. + INFO = "Informational" + LOW = "Low" + MEDIUM = "Medium" + HIGH = "High" + CRITICAL = "Critical" + + @property + def priority(self): + # NOTE(valerio.rico): less => more important + priorities = { + self.INFO: 4, + self.LOW: 3, + self.MEDIUM: 2, + self.HIGH: 1, + self.CRITICAL: 0, + } + return priorities[self] + + +class SecurityCheckStatus(str, enum.Enum): + """External secbot check status.""" + + NOT_STARTED = "not_started" + IN_PROGRESS = "in_progress" + ERROR = "error" # an exception has happened. + + # All the data has been obtained. + FAIL = "fail" # we have vulnerabilities. + SUCCESS = "success" # we don't have vulnerabilities, or they are acceptable. + + +class ScanStatus(str, enum.Enum): + """Internal (technical) secbot check status.""" + + NEW = "new" + IN_PROGRESS = "in_progress" + SKIP = "skip" # we decide to skip a scan for some reason. + ERROR = "error" # an exception has happened. + DONE = "done" # all the data has been obtained. diff --git a/app/secbot/settings.py b/app/secbot/settings.py new file mode 100755 index 0000000..4ab13a6 --- /dev/null +++ b/app/secbot/settings.py @@ -0,0 +1,11 @@ +from pydantic import BaseSettings, PostgresDsn + + +class SecbotSettings(BaseSettings): + postgres_dsn: PostgresDsn + + class Config: + env_prefix = "secbot_" + + +settings = SecbotSettings() diff --git a/app/secbot/utils.py b/app/secbot/utils.py new file mode 100755 index 0000000..52652ef --- /dev/null +++ b/app/secbot/utils.py @@ -0,0 +1,48 @@ +import json +from importlib import import_module + +from pydantic import BaseModel + +from app.secbot.schemas import PYDANTIC_CLS_PATH + + +def load_cls(path: str) -> BaseModel: + """Load a class from a path""" + module, class_name = path.rsplit(".", 1) + return getattr(import_module(module), class_name) + + +def serializer(values): + """Convert JSON-serializable objects back into original data types. + + This function recursively handles the conversion of input values, + such as dictionaries for Pydantic models, into their original data types. + by checking for a special key in the dictionary which + is essentially putted by the deserializer function. + """ + if isinstance(values, (list, tuple)): + return tuple(serializer(value) for value in values) + if isinstance(values, dict): + if PYDANTIC_CLS_PATH in values.keys(): + cls = load_cls(values.get(PYDANTIC_CLS_PATH)) + return cls.parse_obj(values) + else: + return {key: serializer(value) for key, value in values.items()} + return values + + +def deserializer(values): + """Convert values into JSON-serializable objects. + + This function handles the conversion of values, such as Pydantic models, + into JSON-serializable objects. + For Pydantic models, it creates a dictionary with a special key storing the model's path, + allowing for easy re-serialization before a Celery task execution. + """ + if isinstance(values, (list, tuple)): + return tuple(deserializer(value) for value in values) + if isinstance(values, dict): + return {key: deserializer(value) for key, value in values.items()} + if issubclass(type(values), BaseModel): + return json.loads(values.json()) + return values diff --git a/app/settings.py b/app/settings.py new file mode 100755 index 0000000..3f564d0 --- /dev/null +++ b/app/settings.py @@ -0,0 +1,68 @@ +from __future__ import annotations + +import os.path +import pathlib +from typing import List, Optional, Set, Union + +from pydantic import AnyUrl, BaseModel, BaseSettings, SecretStr + +BASE_PATH = pathlib.Path(os.path.dirname(__file__)) + + +def flatten_settings_values(app_settings: Settings) -> Set[Union[str, int]]: + """Flattering all values from settings recursively.""" + + def values(data): + if hasattr(data, "dict"): + return [values(value) for value in data.dict().values()] + elif isinstance(data, dict): + return [values(value) for value in data.values()] + elif isinstance(data, list): + return [values(item) for item in data] + elif isinstance(data, SecretStr): + return data.get_secret_value() + elif isinstance(data, object): + return str(data) + return data + + def flatten(arg): + if not isinstance(arg, list): + return [arg] + return [x for sub in arg for x in flatten(sub)] + + settings_values = flatten(values(app_settings)) + return set(settings_values) + + +class GitlabConfig(BaseModel): + host: AnyUrl + webhook_secret_token: SecretStr + auth_token: SecretStr + prefix: str + + +class Settings(BaseSettings): + app_id: str = "security-bot" + app_name: str = "Security Bot" + app_host: str = "localhost" + app_port: int = 5000 + + debug: bool = False + docs_enable: bool = True + + # Inputs + gitlab_configs: List[GitlabConfig] + + # URLS + sentry_dsn: Optional[AnyUrl] = None + celery_broker_url: AnyUrl = "redis://redis:6379" + celery_result_backend: AnyUrl = "redis://redis:6379" + + class Config: + # Use this delimiter to split env variables + # e.g. + # DEFECTDOJO__URL=123 -> {"defectdojo": {"url": "123"}} + env_nested_delimiter = "__" + + +settings = Settings() diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100755 index 0000000..f358dff --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,64 @@ +version: '3.8' +services: + app: + build: + context: . + dockerfile: Dockerfile + ports: + - "5000:5000" + env_file: + - .env.dev + volumes: + - ./app/:/opt/app/ + depends_on: + - redis + command: start_app + + security_gateway: + build: + context: . + dockerfile: Dockerfile + ports: + - "5001:5001" + env_file: + - .env.dev + volumes: + - ./app/:/opt/app/ + depends_on: + - redis + command: start_security_gateway + + worker: + build: + context: . + dockerfile: Dockerfile + env_file: + - .env.dev + volumes: + - ./app/:/opt/app/ + depends_on: + - app + - redis + command: start_celery + + redis: + image: redis:6.2-alpine + ports: + - "127.0.0.1:6379:6379" + + db: + image: postgres:14 + restart: always + command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"] + environment: + POSTGRES_DB: secbot + POSTGRES_USER: secbot + POSTGRES_PASSWORD: foobar + PGDATA: /data/db + ports: + - "127.0.0.1:5432:5432" + volumes: + - db:/data/db + +volumes: + db: diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh new file mode 100755 index 0000000..387689c --- /dev/null +++ b/docker-entrypoint.sh @@ -0,0 +1,80 @@ +#!/usr/bin/env bash + +### Uvicorn common settings ### +UVICORN_PORT=${UVICORN_PORT:-"5000"} +UVICORN_SECURITY_GATEWAY_PORT=${UVICORN_SECURITY_GATEWAY_PORT:-"5001"} +UVICORN_RELOAD=${UVICORN_RELOAD:-"false"} +UVICORN_LOG_LEVEL=${UVICORN_LOG_LEVEL:-"info"} + +### Celery common settings ### +CELERY_LOG_LEVEL=${CELERY_LOG_LEVEL:-"info"} +CELERY_MIN_WORKERS=${CELERY_MIN_WORKERS:-"1"} +CELERY_MAX_WORKERS=${CELERY_MAX_WORKERS:-"2"} + +if [ $UVICORN_RELOAD == "true" ]; then + UVICORN_START_ARGS="${UVICORN_START_ARGS} --reload" +else + ### Not valid with --reload + export UVICORN_WORKERS=${UVICORN_WORKERS:-"1"} +fi + +function export_overriden_env() { + # Override env variables with .env.override file + # It will allow to have different env variables for local development and production + FILE=".env.override" + if [[ -f "$FILE" ]]; then + export $(grep -v '^#' $FILE | xargs -d '\n') + else + echo "Override env $FILE not found" + fi +} + +function run_migrations() { + echo "Running migration" + alembic -c /opt/app/secbot/alembic.ini upgrade head +} + +function run_app() { + echo "Starting security bot app" + export_overriden_env + run_migrations + uvicorn app.main:app --host 0.0.0.0 --port ${UVICORN_PORT} --log-level ${UVICORN_LOG_LEVEL} ${UVICORN_START_ARGS} +} + +function run_security_gateway() { + echo "Starting security bot security gateway" + export_overriden_env + uvicorn app.main:security_gateway_app --host 0.0.0.0 --port ${UVICORN_SECURITY_GATEWAY_PORT} --log-level ${UVICORN_LOG_LEVEL} ${UVICORN_START_ARGS} +} + +function run_celery() { + echo "Starting security bot celery worker" + export_overriden_env + celery -A app.main:celery_app worker --autoscale=${CELERY_MAX_WORKERS},${CELERY_MIN_WORKERS} --loglevel ${CELERY_LOG_LEVEL} +} + +case $1 in + "shell") + bash + ;; + "start_app") + run_app + ;; + "start_security_gateway") + run_security_gateway + ;; + "start_celery") + run_celery + ;; + "migrate") + run_migrations + ;; + *) + echo "Please use of next parameters to start:" + echo " help: help information" + echo " shell: run shell" + echo " migrate: run migrations" + echo " start_app: run app" + echo " start_celery: run celery" + ;; +esac diff --git a/docs/Makefile b/docs/Makefile new file mode 100755 index 0000000..d4bb2cb --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/conf.py b/docs/conf.py new file mode 100755 index 0000000..8fed5b5 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,37 @@ +# Configuration file for the Sphinx documentation builder. +# +import os +import sys + +sys.path.insert(0, os.path.abspath("../")) + +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "Security Bot" +copyright = "2023, Exness" +author = "Maxim Sokolov" +version = "0.1.0" +release = version + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + "sphinx.ext.duration", + "sphinx.ext.doctest", + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.intersphinx", +] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "sphinx_rtd_theme" diff --git a/docs/configuration.rst b/docs/configuration.rst new file mode 100755 index 0000000..f4cfafb --- /dev/null +++ b/docs/configuration.rst @@ -0,0 +1,204 @@ +Configuration +============= + +The content of this page is focused on the peculiarities and details of the +service and workflow configuration files to let you make more informed +decisions when customizing the Security Bot (SecBot) service for your needs. + +.. _service_configuration: + +Service Configuration +--------------------- + +SecBot's configuration implies setting up all the + +* internal (queues and databases) and +* external (Inputs, Scans, Outputs, and Notifiers) units + +this service collaborates with and specifying other relevant parameters +(metrics) as well. + +Therefore, you need to review and update the respective ``/.env.dev`` file in +advance to reflect your environment's peculiarities. + +.. code-block:: text + + # Excerpt from .env.dev + + ... + CELERY_BROKER_URL=redis://redis:6379/0 + CELERY_RESULT_BACKEND=redis://redis:6379/0 + + SECBOT_POSTGRES_DSN=postgresql+asyncpg://secbot:foobar@db:5432/secbot + + GITLAB_CONFIGS=[ + { + "host":"https://git.env.local/", # GitLab's host (instance) + "webhook_secret_token":"SecretStr", # secret token used when a webhook is being set up + "auth_token":"SecretStr", # token given to the user who will communicate with the API to get check results + "prefix":"GIT_LOCAL" # prefix used when a security_check_id is being generated + } + ] + + DEFECTDOJO__URL=https://defectdojo.env.local # DefectDojo's host + DEFECTDOJO__TOKEN=defectdojo_token # token given upon user registration to communicate with the DefectDojo's API + DEFECTDOJO__USER=defectdojo_username # registered user's name + DEFECTDOJO__USER_ID=10 # registered user's ID + + SLACK_TOKEN=token_here # token given to the user that is allowed to read Slack's channels + ... + +After that, save the file and rebuild the service. + +.. code-block:: console + + $ docker-compose up --build + +Additionally, according to the ``/.gitignore`` file, any parameter specified +in ``/env.dev`` can be redefined in ``/.env.override`` for testing and other +purposes. + +.. code-block:: text + + # Excerpt from .gitignore + + ... + # Personal override env + .env.override + ... + +To do this, + +1. Rename the original file of ``/.env.override.example`` accordingly +2. Specify the new values of existing variables there, for example modify ``DEFECTDOJO__TOKEN=defectdojo_token`` + +.. code-block:: text + + # Excerpt from .env.override + + ... + DEFECTDOJO__TOKEN=my_personal_token + ... + +3. Save the file. +4. Rebuild the service. + +.. _workflow_configuration: + +Workflow Configuration +---------------------- + +The workflow configuration is a set of policies according to which SecBot +reacts to incoming events, processes the data, and yields the results. This +configuration is based on the ``app/config.yml`` file that contains two +sections: *components* and *jobs*. + +The first section introduces the hired external units (Scans, Outputs, and +Notifiers) which SecBot collaborates with. It might include a unit’s name +(handler name) and its settings: format of data it returns, URLs, keys, etc. + +The following excerpt shows an example of three units belonging to different +types. (The environment variable values refer to the ``.env.dev`` file.) + +.. code-block:: yaml + + # Excerpt from app/config.yml + + ... + components: + # Scan Gitleaks + gitleaks: + handler_name: "gitleaks" + config: + format: "json" # data format in a response + # Output DefectDojo + defectdojo: + handler_name: "defectdojo" + env: + url: "DEFECTDOJO__URL" # host + secret_key: "DEFECTDOJO__TOKEN" # token given upon user registration to communicate with the API + user: "DEFECTDOJO__USER" # registered user's name + lead_id: "DEFECTDOJO__USER_ID" # registered user's ID + # Notifier Slack + slack: + handler_name: "slack" + config: + render_limit: 10 # maximum number of lines (findings) in a notification + channel: # channels to report findings + - test-sec-security-bot + - my-personal-channel + env: + token: "SLACK_TOKEN" # token given to the user that is allowed to read the channels + ... + +.. note:: + + For now, these are the only components SecBot collaborates with. However, + it must be sufficient for the first version of the product to let you + assess its work. + +The second section, "jobs", defines the policies SecBot follows in its work to +yield the results. When a specific event matching the *rules* of a +policy comes up, a processing plan (job) is created. It contains the necessary +number of tasks to be sequentially executed by the relevant external units +(components). + +The following excerpts from the ``app/config.yml`` file show an example of one job +to explain the idea. + +.. code-block:: yaml + + # Excerpt from app/config.yml + + ... + jobs: + # human-readable job name to be used as a reference in logs + - name: Common merge request event + + # two-level identifier of an input entity + rules: + gitlab: # first level + event_type: "merge_request" # second level + project.path_with_namespace: /gitlab-test/ # second level + +, where + +* **first level** is a development or distribution platform (Input) or any custom workflow name. +* **second level** is :term:`Input entity` (input event) types and keys (JSON path strings) to apply checks and filtration within the input events. For available keys, refer to the objects from a payload (request body). For example, ``project.path_with_parameters`` from ``POST [host]/v1/gitlab/webhook`` enables the filtering of input events originating from specific repositories. + +Also, note that the arguments at the second level are joined with logical AND +unless they are matching and thus mutually exclusive. That is, if, for +example, ``event_type: "tag_push"`` and ``event_type: "merge_request"`` are +specified in the same job, the last one will be taken. + +.. code-block:: yaml + + # Excerpt from app/config.yml (continuation) + + # handlers to find leaks, vulnerabilities, and other security-related issues + scans: + - gitleaks + + # handlers to aggregate and normalize the Scans' results + outputs: + - defectdojo + + # handlers to report the Outputs' results + notifications: + - slack + ... + +.. note:: + + For now, only one job is allowed to cover a particular event. If your + configuration implies that two or more jobs can be created to serve the + same event, it will result in an error. + +Information from the ``app/config.yml`` file is read once as soon as SecBot +starts. Therefore, if you make any changes to it, you need to stop and restart +the service to apply them. + +.. code-block:: console + + $ docker-compose stop + $ docker-compose up -d \ No newline at end of file diff --git a/docs/getting-started.rst b/docs/getting-started.rst new file mode 100755 index 0000000..cdcb43a --- /dev/null +++ b/docs/getting-started.rst @@ -0,0 +1,127 @@ +Getting Started +=============== + +On this page, you will find all the necessary information to dive into the +Security Bot (SecBot) project to + +* set up the service and the documentation generator it uses, +* configure and integrate it with your service, +* ensure communication via API, and +* get familiar with the main concepts and limits. + +Yet, we provide detailed descriptions and insights on separate pages of this +documentation. + +Prerequisites +------------- + +Since SecBot is a Python application running in a container on Kubernetes, +make sure that the relevant components and their packages are installed and +available in your local environment. + +**Kubernetes-related**: + +* `Docker `_ +* `Kubernetes `_ +* `Kubernetes Cluster `_ +* Container registry, for example `Docker Hub `_ +* and other Containerization tools, for example `Docker Compose `_ + +**Python-related**: + +* `Python `_ +* `PIP `_ +* `Poetry `_ + +Additionally, we employ + +* `Sphinx `_ as a documentation generator and +* `draw.io `_ as a tool for creating schemes and diagrams. + +Deployment +---------- + +Follow these general steps to install and build the SecBot + +1. Clone the repository: + + a. visit the project's repository to copy the URL under :guilabel:`Clone` + b. run the ``git clone`` command to create a local copy + + .. code-block:: console + + $ git clone path/to/project.git + +2. Build and run the SecBot service. + + .. code-block:: console + + $ docker-compose up --build + +Service Configuration +--------------------- + +The ``/.env.dev`` file defines the location, keys, and other parameters of the +internal and external units SecBot communicates with: queues, databases, +:ref:`Inputs, Scans, Outputs, and Notifiers `. + +1. Review this file and make the necessary changes to it based on your environment's peculiarities, such as the variables within ``GITLAB_CONFIGS``. +2. Save the file and rebuild the service. + +.. code-block:: console + + $ docker-compose up --build + +For test and other reasons, you can redefine any parameter in the +``/.env.override`` file for your separate sandbox environment. To do this, + +1. Rename the original file of ``/.env.override.example`` accordingly +2. Specify the new values of existing variables there, for example modify ``DEFECTDOJO__TOKEN=defectdojo_token`` + +.. code-block:: text + + # Excerpt from .env.override + + ... + DEFECTDOJO__TOKEN=my_personal_token + ... + +3. Save the file. +4. Rebuild the service. + +.. code-block:: console + + $ docker-compose up --build + +.. note:: + + For more detailed information on this topic, see + :ref:`Configuration `. + +Workflow Configuration +---------------------- + +The ``/app/config.yml`` file defines the policies SecBot follows in its work: +which Scans to launch to check input entities of a particular type, which +Outputs to use to aggregate the Scans' results, and so on. You can take the +original version and use it as is or update the file according to your needs. +In the latter case, you will need stop and restart the service. + +.. code-block:: console + + $ docker-compose stop + $ docker-compose up -d + +.. note:: + + For more detailed information on this topic, see + :ref:`Configuration `. + +Integration +----------- + +Since SecBot communicates with different units via their respective APIs and +triggers in response to specific input events, you are expected to + +* :ref:`obtain authorization with these units ` (Inputs, Outputs, and Notifiers) and +* :ref:`specify triggers ` on your development and distribution platform (Input), such as system hooks (or webhooks) for GitLab. \ No newline at end of file diff --git a/docs/glossary.rst b/docs/glossary.rst new file mode 100755 index 0000000..6959b3a --- /dev/null +++ b/docs/glossary.rst @@ -0,0 +1,98 @@ +.. _glossary_and_inventory: + +Glossary and Inventory +====================== + +On this page, you will find the + +* brief explanations of the units SecBot's architecture is based on, +* lists of those supported and used in configuration, and +* descriptions of other related concepts. + +.. glossary:: + + Input + Input is a code repository, storage, or development or distribution + platform, such as GitLab or Docker Registry, changes to which need + extended security-related validation. + + +------------+----------------------------------------------+ + | Input | Source | + +============+==============================================+ + | ``gitlab`` | `GitLab Docs `_ | + +------------+----------------------------------------------+ + + Input entity + Input entity (or input event) is a substantial amount of data + (payload) to be validated. This data can be filtered out based on some + configuration rules so that only part of it is actually checked. You + can specify one or more of the event types we support (see the + following table) and any other keys (JSON paths) of your choice. + + +-------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ + | Event type | Source | + +===================+=========================================================================================================================================+ + | ``push`` | `Webhook events: push events `_ | + +-------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ + | ``tag_push`` | `Webhook events: tag events `_ | + +-------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ + | ``merge_request`` | `Webhook events: merge request events `_ | + +-------------------+-----------------------------------------------------------------------------------------------------------------------------------------+ + + .. code-block:: text + + # Excerpt from /app/config.yml + + ... + jobs: + - name: Common merge request event + rules: + gitlab: # reserved name (Input) + event_type: "merge_request" # one of the filtering parameters (Event type) + ... + + Scan + Scan is an external code analysis tool for applying the DevOps and + security best practices to development and integration flows. It, for + example, can detect hardcoded secrets (passwords, API keys, or tokens + in Git repositories) or evaluate how certain changes might affect the + overall quality or performance of your application. The result of its + work is raw defect data to be passed to Outputs. + + +--------------+--------------------------------------------------------------+ + | Scan | Source | + +==============+==============================================================+ + | ``gitleaks`` | `Gitleaks on GitHub `_ | + +--------------+--------------------------------------------------------------+ + + Output + Output is an external defect management system specially integrated + with SecBot to aggregate the check results from different Scans, merge + the duplicates, and do other relevant things to prepare a normalized + readable report for Notifiers. A piece of this report (problem, + vulnerability, or any other security issue) is called "finding." + + +----------------+---------------------------------------------------------+ + | Output | Source | + +================+=========================================================+ + | ``defectdojo`` | `DefectDojo on GitHub `_ | + +----------------+---------------------------------------------------------+ + + Findings + For findings, see "Output." + + Notifier + Notifier (referred to as "notification" in the `/app/config.py` file) + is an instant messaging program integrated with SecBot to inform + interested parties of detected security issues (findings). + + +-----------+---------------------------------------+ + | Notifier | Source | + +===========+=======================================+ + | ``slack`` | `Slack Website `_ | + +-----------+---------------------------------------+ + + Job + Job is three sets of tasks, at least one for a Scan, one for an + Output, and one for a Notifier, to be executed sequentially to process + a particular input entity type and yield the relevant results (findings). \ No newline at end of file diff --git a/docs/images/defectdojo-user.png b/docs/images/defectdojo-user.png new file mode 100755 index 0000000000000000000000000000000000000000..2e32429240b0643d10dbcca8c3f02452c934570f GIT binary patch literal 119961 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

QUQsvg&MXwSj}{cclo` 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 n);hqW{{KOsAoSld6LfyR>_ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/images/general-scheme.drawio.png b/docs/images/general-scheme.drawio.png new file mode 100755 index 0000000000000000000000000000000000000000..b070f69bef83c36e157b29deb1511714451f3f7b GIT binary patch literal 73881 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 E0#c`z0ssI2 literal 0 HcmV?d00001 diff --git a/docs/images/gitlab-access-token.png b/docs/images/gitlab-access-token.png new file mode 100755 index 0000000000000000000000000000000000000000..72f867aff318dc8ab208fcc8573b1a0f5e12e385 GIT binary patch literal 255907 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%0AU7O3#Nl_eu($(hZ*H_0vfq<$<{`v71s1}XC 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%0Ap}J^QIG$lTzL8hh(D4 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 literal 0 HcmV?d00001 diff --git a/docs/images/gitlab-system-hooks.png b/docs/images/gitlab-system-hooks.png new file mode 100755 index 0000000000000000000000000000000000000000..32acb6b2d1d68eda3046048dc68ba36409465887 GIT binary patch literal 103936 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/rCPzfk+H5vjGGC6TD4yuFp8oT4ihm36iQFmhm1blgXEj0S2GeICKwNChn1VaQc84D9IgaZC19hHcaUip5RwvKqCHo0i5PEKBhmjm2q1gJJqrysYohrw4EFSR39gny8ydDgwd/gnhMNF3rNlqjtLmFdWQLyAPt2UIHBjgCmjlGdXy2SKiHRe7pes3e2eu8XAGIp4mwbXX+/B95F960/dBYvux5/vNoMrZeUJkrV6YMN2ibA3CagwK/1KKEvvuL/XcqgTwwZB+ilDZsy3ymU5KA1cxSmhY1HBclZJWnXXyA3Vb9rhPAdiD0ayQX5DPNJcryywbIA5bFfGYItHFwoRhclmgTl6WEFP3tkIkQpswZdElCxxCeNVJpsAJ8iXw8aETIuHBqMREN+iiyfEOEr2MmAVvIoJgegScbYVVVQDRylBTQUrV8amJCwFLUqayjGopBwWhndsiwtF+DPIt3tIPl3z1Zr3hn4Lzr2Rdxr6df6djukHPaQ/ohwHGLHeCCAIhqYI6aeZ/3oAcDtWgNNDBRQBwO4F/+cMALbZMf+DPvMPXj3/oOsNgNtD/tXurx+z/4y7v86X/+sG8nU/Rv5YvkOJkkdgHGOv6j5G15Ev/TYzFeXqBc5yVLnky9v0I3DhL7b9qRqlhV+y8GGQF2dJ+eZsq0rZ8JBfe2HTGBBviJCFiB/a+daZKlExaKAixxgikOOn6jCa+FE9fKM4nU25cuw924DcREzXzEOqVfmNTjd0rRmyNEOZH2qGUrkUj328goZvWEHOq1CQDbSgpEebMyto9NIUhBLMf6qe5XWplSjtGsnC81WX0fYPf7VV5+B1qHOg7Zd0Q2dWZx5OO5DnETI7f1A8KE/3RSy/VlVVjn2sPPfl8y4lz6bk7UXk2VYyfYlAtWXtWIqL8qUott8pvjDFF19kmtKw74vMgb1Ni0UGdClPMNRUpQeOtvJ09B366MLybMoRv0cgo5S927c2tKZ4X1r4UhQ3pYF7G4FOGEk63YY6prZ71JM3L0Y+B7PIh7PDw1p2uDn1bKafFlnkOzqXdjPzgTAk3CHTyjjKDheEVjDfGv95yshRwqvzIOaMPqJc6xGNkJZUVhAkOIxEkaBAWpCJZexBMlbwEvs+2Ze/rs41AueITKD3GKa43vWzgu1x+e3SfCliYHnC6HHxZBlsq57CznYG8WNc42rnNevwuUB7pw7rTlUibThKTs9NznGY4LQ8TDgfFfVcsPtGqOgfF/WsKngjXOhr4Rm5EMXdf/eytXT3D0hw8xc= \ No newline at end of file diff --git a/docs/images/job-graph.drawio.png b/docs/images/job-graph.drawio.png new file mode 100755 index 0000000000000000000000000000000000000000..cadf5b342cc29cb47d1e2e8478caf408eaee3ad3 GIT binary patch literal 39013 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 literal 0 HcmV?d00001 diff --git a/docs/images/slack-dashboard.png b/docs/images/slack-dashboard.png new file mode 100755 index 0000000000000000000000000000000000000000..6122a73903ea37f62c73e99035b046db3cc0ae3d GIT binary patch literal 388800 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�Qic?-9bVpvy1~-9aYPFAo%R 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 + getting-started + configuration + integration + glossary + +The **Security Bot** (SecBot) is an orchestration service designed to +communicate with various external units (see the :ref:`following scheme `) +to detect security-related issues in developers' code. It can be implemented +as an extra pipeline stage to be passed (along with linting, unit-tests, and +build) or used in any other way. + +In its work, this service + +1. receives from development and distribution platforms ("Inputs") information on changes that a software engineer contributes ("input entity") +2. based on its configuration and the input entity's type, draws up a processing plan ("job"; see an example of it :ref:`later `) +3. according to this plan, creates a necessary number of tasks for different units to be successively performed to + + a. scan the input entity with code analysis tools ("Scans") + b. aggregate the found security issues from Scans, merge duplicates, and do other relevant things with defect management systems ("Outputs") + c. inform the interested parties of the results by means of instant messaging ("Notifiers") + +4. provides the "Input" platforms with the check results (status) on request. (Based on this status—"success" or "fail"—the changes being contributed are allowed or blocked.) + +.. _general-scheme-image: + +.. image:: /images/general-scheme.drawio.png + :alt: General scheme + +.. note:: + + As the scheme suggests, SecBot is split into two instances running in + separate containers to ensure high availability and distribute the load. + One instance is responsible for receiving requests to process data, whereas + the other is dedicated to providing the results of this processing. + +.. _job-graph-image: + +The following example of a processing plan, presented as a graph, implies that +SecBot's job is configured to use two Scans, three Outputs, and one Notifier. +The overall number of tasks is 11. + +.. image:: /images/job-graph.drawio.png + :width: 350px + :align: center + :alt: Job graph \ No newline at end of file diff --git a/docs/integration.rst b/docs/integration.rst new file mode 100755 index 0000000..40c5ddd --- /dev/null +++ b/docs/integration.rst @@ -0,0 +1,185 @@ +.. _integration: + +Integration +=========== + +On this page, you will find an adequate checklist and step-by-step +instructions to ensure the successful integration of your service with the +Security Bot (SecBot) solution. + +Configuration Files +------------------- + +The service (``/.env.dev``) and workflow (``/app/config.yml``) +:doc:`configuration files ` are updated to meet your +environment's peculiarities and issue processing needs. + +If you have made additional alterations, rebuild SecBot and start it again. + +.. code-block:: console + + $ docker-compose stop + $ docker-compose up --build + $ docker-compose up -d + +.. _authorization: + +Authorization +------------- + +All external units that SecBot communicates with via APIs require +authorization. Therefore, the user that performs the communication should have +the respective tokens. + +.. _gitlab-auth: + +**For GitLab** + +1. Sign in to your account +2. Click the profile icon in the upper-right corner and then click **Edit profile** +3. Click **Access Token** on the **User Settings** left-side menu +4. On the open page, enter your *Token name*, check the *Expiration date*, select ``read_api`` under **Select scopes**, and then click the :guilabel:`Create personal access token` button below + +.. image:: /images/gitlab-access-token.png + :alt: GitLab access token + +5. Copy *Your new personal access token* generated by GitLab and ensure you securely store it, as it will not be displayed again. + +**For DefectDojo** + +1. Log in under the admin's (superuser's) account +2. Point to the *Users* left-side menu and then click **Users** +3. On the open page, click the *Settings* toolbar button and then click **New User** +4. On the **Add User** page, enter the following parameters of the user that will communicate with the API: + + a. *Username* and *Password* under **Default Information** + b. ``Maintainer`` as the *Global role* under **Global Role** + +5. Click the :guilabel:`Submit` button and make sure that the *User has been added successfully* + +.. image:: /images/defectdojo-user.png + :alt: DefectDojo SecBot user + +6. Log in under the added user's account +7. Click the profile icon in the upper-right corner and then click **API v2 Key** +8. On the open page, copy *Your current API key* generated by DefectDojo and ensure you securely store it. + +**For Slack** + +1. Go to ``https://api.slack.com`` to sign in to your workspace +2. Create an app; to do it, + + a. Click the :guilabel:`Your Apps` menu + b. Click the :guilabel:`Create New App` button on the open page + c. Choose **From scratch** in the open **Create an app** dialog box + d. Enter your *App Name* and *Pick the workspace* where you want to install this app in the following **Name app & choose workspace** dialog box + e. Click the :guilabel:`Create App` button + +3. Click the **OAuth & Permissions** left-side menu under **Features** on the app's dashboard +4. Scroll down to the **Scopes** section and click the :guilabel:`Add an Oath Scope` button under **Bot Token Scopes** to select ``chat:write`` +5. Scroll up to the **OAuth Tokens for Your Workspace** section and click the :guilabel:`Install to Workspace` button + + * Allow the app to access the workspace if requested + +6. Copy your *Bot User OAuth Token* generated by Slack and ensure you securely store it. + +.. image:: /images/slack-dashboard.png + :alt: Slack Dashboard + +.. _input_entity_sources: + +Input Entity Sources +-------------------- + +The SecBot instance responsible for receiving requests to process data +triggers as soon as a relevant input event comes up. Thus, you are expected to +specify these triggers for supported development and distribution platforms +(Inputs). + +**For GitLab** + +1. Sign in under an admin's account +2. Click the **System Hooks** left-side menu to add new or update existing system hooks +3. On the open page, enter in the **URL** text box the reference to the method used to receive information on changes made to the repository in your environment + + * *[host]/v1/gitlab/webhook* + +4. Enter the :ref:`authentication token ` for your requests in the **Secret token** text box +5. Select the types of input events you want to be processed under **Trigger**, for example, any supported :term:`Input entity` type like ``Push events``, ``Tag push events``, and ``Merge request events`` + +.. image:: /images/gitlab-system-hooks.png + :alt: GitLab system hooks + +6. Click the :guilabel:`Add system hook` or :guilabel:`Save changes` button below. + +API +--- + +Communication with SecBot's API involves providing input entities or receiving +check results via the dedicated endpoints (instances). Follow + +* ``[host]:5000/docs`` and +* ``[host]:5001/docs``, respectively. + +In the first case, mind the + +1. :term:`Input entity` (input event) type you will specify as the ``x-gitlab-event`` header parameter and the +2. respective payload in the request body. + +A specific result is retrieved by *security_check_id*, which is formed by +concatenating the following pieces: + +1. input platform (e.g. git) prefix, +2. sha256 of the project path, and +3. complete commit hash. + +.. code-block:: text + + # security_check_id example + + GIT_LOCAL_d42052411d2729e637980c355cf6a8ea8e41b8688b98c34a125b71b7f2c7f76e + +Pipeline +-------- + +Integration of SecBot into your pipeline as an additional stage is an option +we suggest that you consider. Depending on the status received upon checks, +this stage might + +* get passed ('success'), +* stay pending ('not_started' or 'in_progress'), or +* fail ('error' or 'fail'). + +The following excerpt demonstrates a comprehensive example of how this +integration can be implemented. + +.. code-block:: yaml + + # Excerpt from .../pipeline.yml + + ... + .gate-sec-scripts: + before_script: + - apk add curl jq + - SECURITY_CHECK_URL="https://[gateway_url]/v1/security/gitlab/check" + - SECURITY_CHECK_UID="GIT_LOCAL_$(echo -n "${CI_SERVER_HOST}:${CI_PROJECT_PATH}_${CI_COMMIT_SHA}" | sha256sum | head -c64)" + script: + - SECURITY_CHECK_STATUS=$(curl -k -s -w " %{http_code}" $SECURITY_CHECK_URL/${SECURITY_CHECK_UID}) + - SECURITY_CHECK_STATUS_JSON=$(echo $SECURITY_CHECK_STATUS | awk '{print $1}') + - SECURITY_CHECK_STATUS_CODE=$(echo $SECURITY_CHECK_STATUS | awk '{print $2}') + - | + if [ "$SECURITY_CHECK_STATUS_CODE" != "200" ]; then + echo " Something went wrong, status: $SECURITY_CHECK_STATUS" + exit 1 + fi + - SECURITY_CHECK_STATUS_JSON_STATUS_DESCRIPTION='' + - SECURITY_CHECK_STATUS_JSON_STATUS=$(echo $SECURITY_CHECK_STATUS_JSON | jq -r '.status') + - | + if [ $SECURITY_CHECK_STATUS_JSON_STATUS = "fail" ]; then + SECURITY_CHECK_STATUS_JSON_STATUS_DESCRIPTION="--> Vulnerabilities found" + elif [ $SECURITY_CHECK_STATUS_JSON_STATUS = "success" ]; then + SECURITY_CHECK_STATUS_JSON_STATUS_DESCRIPTION="--> No vulnerabilities found" + fi + - echo " Response Code --> $SECURITY_CHECK_STATUS_CODE" + - echo " Status --> $SECURITY_CHECK_STATUS_JSON_STATUS $SECURITY_CHECK_STATUS_JSON_STATUS_DESCRIPTION" + ... \ No newline at end of file diff --git a/docs/make.bat b/docs/make.bat new file mode 100755 index 0000000..954237b --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/k8s/configmap.yml b/k8s/configmap.yml new file mode 100644 index 0000000..7155f45 --- /dev/null +++ b/k8s/configmap.yml @@ -0,0 +1,62 @@ +# jobs configuration yml +apiVersion: v1 +kind: ConfigMap +metadata: + name: security-bot-configuration +data: + config.yml: | + version: 1.0 + + components: + gitleaks: + handler_name: "gitleaks" + config: + format: "json" + defectdojo: + handler_name: "defectdojo" + env: + url: "DEFECTDOJO__URL" + secret_key: "DEFECTDOJO__TOKEN" + user: "DEFECTDOJO__USER" + lead_id: "DEFECTDOJO__USER_ID" + slack: + handler_name: "slack" + config: + render_limit: 10 + channels: + - security-bot + env: + token: "SLACK_TOKEN" + + jobs: + - name: Merge Request Job + rules: + gitlab: + event_type: "merge_request" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack +--- +# environment variables +apiVersion: v1 +kind: ConfigMap +metadata: + name: security-bot-configuration-envs +data: + SENTRY_DSN: "sentry_dsn" + SECBOT_POSTGRES_DSN: "postgres_dsn" + GITLAB_CONFIGS: '[{"host":"https://git.env.local/","webhook_secret_token":"SecretStr","auth_token":"SecretStr","prefix":"GIT_LOCAL"}]' + DEFECTDOJO__URL: "https://defectdojo.env.local" + DEFECTDOJO__TOKEN: "defectdojo_token" + DEFECTDOJO__USER: "defectdojo_username" + DEFECTDOJO__USER_ID: "10" + SLACK_TOKEN: "slack_token" + CELERY_BROKER_URL: "redis://security-bot-redis-svc:6379/0" + CELERY_RESULT_BACKEND: "redis://security-bot-redis-svc:6379/0" + SRE_METRIC_LABEL_TEAM: "SECURITY" + SRE_METRIC_LABEL_SERVICE: "security-bot" + TRACING_TAGS_HOST: "security-bot.env.local" + TRACING_TAGS_CLUSTER: "security-local" diff --git a/k8s/deployment.yml b/k8s/deployment.yml new file mode 100644 index 0000000..e5d3d7d --- /dev/null +++ b/k8s/deployment.yml @@ -0,0 +1,173 @@ +# bot service account +apiVersion: v1 +kind: ServiceAccount +metadata: + name: security-bot +--- +# security bot deployment +apiVersion: apps/v1 +kind: Deployment +metadata: + name: security-bot + labels: + app: security-bot +spec: + replicas: 1 + selector: + matchLabels: + app: security-bot + template: + metadata: + annotations: + labels: + app: security-bot + spec: + serviceAccountName: security-bot + containers: + - name: security-bot + image: exness/security-bot:latest + command: [ "docker-entrypoint.sh" ] + args: [ "start_app" ] + envFrom: + - configMapRef: + name: security-bot-configuration-envs + volumeMounts: + - name: security-bot-configuration-volume + mountPath: /exness/app/config.yml + subPath: config.yml + ports: + - containerPort: 5000 + protocol: TCP + resources: + limits: + cpu: 0.5 + memory: 1Gi + requests: + cpu: 0.5 + memory: 1Gi + volumes: + - name: security-bot-configuration-volume + configMap: + name: security-bot-configuration +--- +# security gateway deployment +apiVersion: apps/v1 +kind: Deployment +metadata: + name: security-bot-gw + labels: + app: security-bot-gw +spec: + replicas: 1 + selector: + matchLabels: + app: security-bot-gw + template: + metadata: + labels: + app: security-bot-gw + spec: + serviceAccountName: security-bot + containers: + - name: security-bot-gw + image: exness/security-bot:latest + command: [ "docker-entrypoint.sh" ] + args: [ "start_security_gateway" ] + envFrom: + - configMapRef: + name: security-bot-configuration-envs + volumeMounts: + - name: security-bot-configuration-volume + mountPath: /exness/app/config.yml + subPath: config.yml + ports: + - containerPort: 5001 + protocol: TCP + resources: + limits: + cpu: 0.5 + memory: 0.5Gi + requests: + cpu: 0.5 + memory: 0.5Gi + volumes: + - name: security-bot-configuration-volume + configMap: + name: security-bot-configuration +--- +# celery deployment +apiVersion: apps/v1 +kind: Deployment +metadata: + name: security-bot-celery + labels: + app: security-bot-celery +spec: + replicas: 4 + selector: + matchLabels: + app: security-bot-celery + template: + metadata: + labels: + app: security-bot-celery + spec: + serviceAccountName: security-bot + containers: + - name: security-bot-celery + image: exness/security-bot:latest + command: [ "docker-entrypoint.sh" ] + args: [ "start_celery" ] + envFrom: + - configMapRef: + name: security-bot-configuration-envs + volumeMounts: + - name: security-bot-configuration-volume + mountPath: /exness/app/config.yml + subPath: config.yml + resources: + limits: + cpu: 1 + memory: 4Gi + requests: + cpu: 1 + memory: 4Gi + volumes: + - name: security-bot-configuration-volume + configMap: + name: security-bot-configuration +--- +# redis deployment +apiVersion: apps/v1 +kind: Deployment +metadata: + name: security-bot-redis + labels: + app: security-bot-redis +spec: + replicas: 1 + selector: + matchLabels: + app: security-bot-redis + template: + metadata: + labels: + app: security-bot-redis + spec: + serviceAccountName: security-bot-redis + containers: + - name: security-bot-redis + image: "redis:6.2-alpine" + resources: + limits: + cpu: 1 + memory: 1Gi + requests: + cpu: 1 + memory: 1Gi +--- +# redis service account +apiVersion: v1 +kind: ServiceAccount +metadata: + name: security-bot-redis diff --git a/k8s/ingress.yml b/k8s/ingress.yml new file mode 100644 index 0000000..14a60ac --- /dev/null +++ b/k8s/ingress.yml @@ -0,0 +1,30 @@ +# ingress configuration +apiVersion: extensions/v1beta1 +kind: Ingress +metadata: + name: security-bot-ingress + annotations: + nginx.ingress.kubernetes.io/proxy-connect-timeout: "10s" + nginx.ingress.kubernetes.io/proxy-send-timeout: "300s" + nginx.ingress.kubernetes.io/proxy-read-timeout: "300s" + nginx.ingress.kubernetes.io/use-regex: "true" + nginx.ingress.kubernetes.io/rewrite-target: /$2 +spec: + tls: + - hosts: + - security-bot.env.local + secretName: sec-bot-tls-certs + rules: + - host: security-bot.env.local + http: + paths: + - path: /inputs(/|$)(.*) + pathType: Prefix + backend: + serviceName: security-bot-svc + servicePort: 5000 + - path: /gateway(/|$)(.*) + pathType: Prefix + backend: + serviceName: security-bot-gw-svc + servicePort: 5001 diff --git a/k8s/sec-bot-tls-certs.yml b/k8s/sec-bot-tls-certs.yml new file mode 100644 index 0000000..755ae16 --- /dev/null +++ b/k8s/sec-bot-tls-certs.yml @@ -0,0 +1,9 @@ +# ingress tls +apiVersion: v1 +kind: Secret +metadata: + name: sec-bot-tls-certs +data: + tls.crt: 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 + tls.key: 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 +type: kubernetes.io/tls diff --git a/k8s/service.yml b/k8s/service.yml new file mode 100644 index 0000000..c39c401 --- /dev/null +++ b/k8s/service.yml @@ -0,0 +1,47 @@ +# security bot service +apiVersion: v1 +kind: Service +metadata: + name: security-bot-svc + labels: + app: security-bot-svc +spec: + type: NodePort + ports: + - name: security-bot + protocol: TCP + port: 5000 + selector: + app: security-bot +--- +# security gateway service +apiVersion: v1 +kind: Service +metadata: + name: security-bot-gw-svc + labels: + app: security-bot-gw-svc +spec: + type: NodePort + ports: + - name: security-bot-gw + protocol: TCP + port: 5001 + selector: + app: security-bot-gw +--- +# redis service +apiVersion: v1 +kind: Service +metadata: + name: security-bot-redis-svc + labels: + app: security-bot-redis-svc +spec: + type: NodePort + ports: + - name: security-bot-redis + protocol: TCP + port: 6379 + selector: + app: security-bot-redis diff --git a/poetry.lock b/poetry.lock new file mode 100755 index 0000000..ae7bce8 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,2756 @@ +# This file is automatically @generated by Poetry and should not be changed by hand. + +[[package]] +name = "aiohttp" +version = "3.8.4" +description = "Async http client/server framework (asyncio)" +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "aiohttp-3.8.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5ce45967538fb747370308d3145aa68a074bdecb4f3a300869590f725ced69c1"}, + {file = "aiohttp-3.8.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b744c33b6f14ca26b7544e8d8aadff6b765a80ad6164fb1a430bbadd593dfb1a"}, + {file = "aiohttp-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1a45865451439eb320784918617ba54b7a377e3501fb70402ab84d38c2cd891b"}, + {file = "aiohttp-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a86d42d7cba1cec432d47ab13b6637bee393a10f664c425ea7b305d1301ca1a3"}, + {file = "aiohttp-3.8.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee3c36df21b5714d49fc4580247947aa64bcbe2939d1b77b4c8dcb8f6c9faecc"}, + {file = "aiohttp-3.8.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:176a64b24c0935869d5bbc4c96e82f89f643bcdf08ec947701b9dbb3c956b7dd"}, + {file = "aiohttp-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c844fd628851c0bc309f3c801b3a3d58ce430b2ce5b359cd918a5a76d0b20cb5"}, + {file = "aiohttp-3.8.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5393fb786a9e23e4799fec788e7e735de18052f83682ce2dfcabaf1c00c2c08e"}, + {file = "aiohttp-3.8.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e4b09863aae0dc965c3ef36500d891a3ff495a2ea9ae9171e4519963c12ceefd"}, + {file = "aiohttp-3.8.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:adfbc22e87365a6e564c804c58fc44ff7727deea782d175c33602737b7feadb6"}, + {file = "aiohttp-3.8.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:147ae376f14b55f4f3c2b118b95be50a369b89b38a971e80a17c3fd623f280c9"}, + {file = "aiohttp-3.8.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:eafb3e874816ebe2a92f5e155f17260034c8c341dad1df25672fb710627c6949"}, + {file = "aiohttp-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c6cc15d58053c76eacac5fa9152d7d84b8d67b3fde92709195cb984cfb3475ea"}, + {file = "aiohttp-3.8.4-cp310-cp310-win32.whl", hash = "sha256:59f029a5f6e2d679296db7bee982bb3d20c088e52a2977e3175faf31d6fb75d1"}, + {file = "aiohttp-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:fe7ba4a51f33ab275515f66b0a236bcde4fb5561498fe8f898d4e549b2e4509f"}, + {file = "aiohttp-3.8.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d8ef1a630519a26d6760bc695842579cb09e373c5f227a21b67dc3eb16cfea4"}, + {file = "aiohttp-3.8.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b3f2e06a512e94722886c0827bee9807c86a9f698fac6b3aee841fab49bbfb4"}, + {file = "aiohttp-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3a80464982d41b1fbfe3154e440ba4904b71c1a53e9cd584098cd41efdb188ef"}, + {file = "aiohttp-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b631e26df63e52f7cce0cce6507b7a7f1bc9b0c501fcde69742130b32e8782f"}, + {file = "aiohttp-3.8.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f43255086fe25e36fd5ed8f2ee47477408a73ef00e804cb2b5cba4bf2ac7f5e"}, + {file = "aiohttp-3.8.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d347a172f866cd1d93126d9b239fcbe682acb39b48ee0873c73c933dd23bd0f"}, + {file = "aiohttp-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3fec6a4cb5551721cdd70473eb009d90935b4063acc5f40905d40ecfea23e05"}, + {file = "aiohttp-3.8.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80a37fe8f7c1e6ce8f2d9c411676e4bc633a8462844e38f46156d07a7d401654"}, + {file = "aiohttp-3.8.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d1e6a862b76f34395a985b3cd39a0d949ca80a70b6ebdea37d3ab39ceea6698a"}, + {file = "aiohttp-3.8.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cd468460eefef601ece4428d3cf4562459157c0f6523db89365202c31b6daebb"}, + {file = "aiohttp-3.8.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:618c901dd3aad4ace71dfa0f5e82e88b46ef57e3239fc7027773cb6d4ed53531"}, + {file = "aiohttp-3.8.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:652b1bff4f15f6287550b4670546a2947f2a4575b6c6dff7760eafb22eacbf0b"}, + {file = "aiohttp-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80575ba9377c5171407a06d0196b2310b679dc752d02a1fcaa2bc20b235dbf24"}, + {file = "aiohttp-3.8.4-cp311-cp311-win32.whl", hash = "sha256:bbcf1a76cf6f6dacf2c7f4d2ebd411438c275faa1dc0c68e46eb84eebd05dd7d"}, + {file = "aiohttp-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:6e74dd54f7239fcffe07913ff8b964e28b712f09846e20de78676ce2a3dc0bfc"}, + {file = "aiohttp-3.8.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:880e15bb6dad90549b43f796b391cfffd7af373f4646784795e20d92606b7a51"}, + {file = "aiohttp-3.8.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb96fa6b56bb536c42d6a4a87dfca570ff8e52de2d63cabebfd6fb67049c34b6"}, + {file = "aiohttp-3.8.4-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a6cadebe132e90cefa77e45f2d2f1a4b2ce5c6b1bfc1656c1ddafcfe4ba8131"}, + {file = "aiohttp-3.8.4-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f352b62b45dff37b55ddd7b9c0c8672c4dd2eb9c0f9c11d395075a84e2c40f75"}, + {file = "aiohttp-3.8.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ab43061a0c81198d88f39aaf90dae9a7744620978f7ef3e3708339b8ed2ef01"}, + {file = "aiohttp-3.8.4-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9cb1565a7ad52e096a6988e2ee0397f72fe056dadf75d17fa6b5aebaea05622"}, + {file = "aiohttp-3.8.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:1b3ea7edd2d24538959c1c1abf97c744d879d4e541d38305f9bd7d9b10c9ec41"}, + {file = "aiohttp-3.8.4-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:7c7837fe8037e96b6dd5cfcf47263c1620a9d332a87ec06a6ca4564e56bd0f36"}, + {file = "aiohttp-3.8.4-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:3b90467ebc3d9fa5b0f9b6489dfb2c304a1db7b9946fa92aa76a831b9d587e99"}, + {file = "aiohttp-3.8.4-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:cab9401de3ea52b4b4c6971db5fb5c999bd4260898af972bf23de1c6b5dd9d71"}, + {file = "aiohttp-3.8.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:d1f9282c5f2b5e241034a009779e7b2a1aa045f667ff521e7948ea9b56e0c5ff"}, + {file = "aiohttp-3.8.4-cp36-cp36m-win32.whl", hash = "sha256:5e14f25765a578a0a634d5f0cd1e2c3f53964553a00347998dfdf96b8137f777"}, + {file = "aiohttp-3.8.4-cp36-cp36m-win_amd64.whl", hash = "sha256:4c745b109057e7e5f1848c689ee4fb3a016c8d4d92da52b312f8a509f83aa05e"}, + {file = "aiohttp-3.8.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:aede4df4eeb926c8fa70de46c340a1bc2c6079e1c40ccf7b0eae1313ffd33519"}, + {file = "aiohttp-3.8.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ddaae3f3d32fc2cb4c53fab020b69a05c8ab1f02e0e59665c6f7a0d3a5be54f"}, + {file = "aiohttp-3.8.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4eb3b82ca349cf6fadcdc7abcc8b3a50ab74a62e9113ab7a8ebc268aad35bb9"}, + {file = "aiohttp-3.8.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bcb89336efa095ea21b30f9e686763f2be4478f1b0a616969551982c4ee4c3b"}, + {file = "aiohttp-3.8.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c08e8ed6fa3d477e501ec9db169bfac8140e830aa372d77e4a43084d8dd91ab"}, + {file = "aiohttp-3.8.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c6cd05ea06daca6ad6a4ca3ba7fe7dc5b5de063ff4daec6170ec0f9979f6c332"}, + {file = "aiohttp-3.8.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:b7a00a9ed8d6e725b55ef98b1b35c88013245f35f68b1b12c5cd4100dddac333"}, + {file = "aiohttp-3.8.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:de04b491d0e5007ee1b63a309956eaed959a49f5bb4e84b26c8f5d49de140fa9"}, + {file = "aiohttp-3.8.4-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:40653609b3bf50611356e6b6554e3a331f6879fa7116f3959b20e3528783e699"}, + {file = "aiohttp-3.8.4-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dbf3a08a06b3f433013c143ebd72c15cac33d2914b8ea4bea7ac2c23578815d6"}, + {file = "aiohttp-3.8.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:854f422ac44af92bfe172d8e73229c270dc09b96535e8a548f99c84f82dde241"}, + {file = "aiohttp-3.8.4-cp37-cp37m-win32.whl", hash = "sha256:aeb29c84bb53a84b1a81c6c09d24cf33bb8432cc5c39979021cc0f98c1292a1a"}, + {file = "aiohttp-3.8.4-cp37-cp37m-win_amd64.whl", hash = "sha256:db3fc6120bce9f446d13b1b834ea5b15341ca9ff3f335e4a951a6ead31105480"}, + {file = "aiohttp-3.8.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fabb87dd8850ef0f7fe2b366d44b77d7e6fa2ea87861ab3844da99291e81e60f"}, + {file = "aiohttp-3.8.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:91f6d540163f90bbaef9387e65f18f73ffd7c79f5225ac3d3f61df7b0d01ad15"}, + {file = "aiohttp-3.8.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d265f09a75a79a788237d7f9054f929ced2e69eb0bb79de3798c468d8a90f945"}, + {file = "aiohttp-3.8.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d89efa095ca7d442a6d0cbc755f9e08190ba40069b235c9886a8763b03785da"}, + {file = "aiohttp-3.8.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4dac314662f4e2aa5009977b652d9b8db7121b46c38f2073bfeed9f4049732cd"}, + {file = "aiohttp-3.8.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe11310ae1e4cd560035598c3f29d86cef39a83d244c7466f95c27ae04850f10"}, + {file = "aiohttp-3.8.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ddb2a2026c3f6a68c3998a6c47ab6795e4127315d2e35a09997da21865757f8"}, + {file = "aiohttp-3.8.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e75b89ac3bd27d2d043b234aa7b734c38ba1b0e43f07787130a0ecac1e12228a"}, + {file = "aiohttp-3.8.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6e601588f2b502c93c30cd5a45bfc665faaf37bbe835b7cfd461753068232074"}, + {file = "aiohttp-3.8.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a5d794d1ae64e7753e405ba58e08fcfa73e3fad93ef9b7e31112ef3c9a0efb52"}, + {file = "aiohttp-3.8.4-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:a1f4689c9a1462f3df0a1f7e797791cd6b124ddbee2b570d34e7f38ade0e2c71"}, + {file = "aiohttp-3.8.4-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:3032dcb1c35bc330134a5b8a5d4f68c1a87252dfc6e1262c65a7e30e62298275"}, + {file = "aiohttp-3.8.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8189c56eb0ddbb95bfadb8f60ea1b22fcfa659396ea36f6adcc521213cd7b44d"}, + {file = "aiohttp-3.8.4-cp38-cp38-win32.whl", hash = "sha256:33587f26dcee66efb2fff3c177547bd0449ab7edf1b73a7f5dea1e38609a0c54"}, + {file = "aiohttp-3.8.4-cp38-cp38-win_amd64.whl", hash = "sha256:e595432ac259af2d4630008bf638873d69346372d38255774c0e286951e8b79f"}, + {file = "aiohttp-3.8.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5a7bdf9e57126dc345b683c3632e8ba317c31d2a41acd5800c10640387d193ed"}, + {file = "aiohttp-3.8.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:22f6eab15b6db242499a16de87939a342f5a950ad0abaf1532038e2ce7d31567"}, + {file = "aiohttp-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7235604476a76ef249bd64cb8274ed24ccf6995c4a8b51a237005ee7a57e8643"}, + {file = "aiohttp-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea9eb976ffdd79d0e893869cfe179a8f60f152d42cb64622fca418cd9b18dc2a"}, + {file = "aiohttp-3.8.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92c0cea74a2a81c4c76b62ea1cac163ecb20fb3ba3a75c909b9fa71b4ad493cf"}, + {file = "aiohttp-3.8.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:493f5bc2f8307286b7799c6d899d388bbaa7dfa6c4caf4f97ef7521b9cb13719"}, + {file = "aiohttp-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a63f03189a6fa7c900226e3ef5ba4d3bd047e18f445e69adbd65af433add5a2"}, + {file = "aiohttp-3.8.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10c8cefcff98fd9168cdd86c4da8b84baaa90bf2da2269c6161984e6737bf23e"}, + {file = "aiohttp-3.8.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bca5f24726e2919de94f047739d0a4fc01372801a3672708260546aa2601bf57"}, + {file = "aiohttp-3.8.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:03baa76b730e4e15a45f81dfe29a8d910314143414e528737f8589ec60cf7391"}, + {file = "aiohttp-3.8.4-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:8c29c77cc57e40f84acef9bfb904373a4e89a4e8b74e71aa8075c021ec9078c2"}, + {file = "aiohttp-3.8.4-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:03543dcf98a6619254b409be2d22b51f21ec66272be4ebda7b04e6412e4b2e14"}, + {file = "aiohttp-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:17b79c2963db82086229012cff93ea55196ed31f6493bb1ccd2c62f1724324e4"}, + {file = "aiohttp-3.8.4-cp39-cp39-win32.whl", hash = "sha256:34ce9f93a4a68d1272d26030655dd1b58ff727b3ed2a33d80ec433561b03d67a"}, + {file = "aiohttp-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:41a86a69bb63bb2fc3dc9ad5ea9f10f1c9c8e282b471931be0268ddd09430b04"}, + {file = "aiohttp-3.8.4.tar.gz", hash = "sha256:bf2e1a9162c1e441bf805a1fd166e249d574ca04e03b34f97e2928769e91ab5c"}, +] + +[package.dependencies] +aiosignal = ">=1.1.2" +async-timeout = ">=4.0.0a3,<5.0" +attrs = ">=17.3.0" +charset-normalizer = ">=2.0,<4.0" +frozenlist = ">=1.1.1" +multidict = ">=4.5,<7.0" +yarl = ">=1.0,<2.0" + +[package.extras] +speedups = ["Brotli", "aiodns", "cchardet"] + +[[package]] +name = "aiosignal" +version = "1.3.1" +description = "aiosignal: a list of registered asynchronous callbacks" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[package.dependencies] +frozenlist = ">=1.1.0" + +[[package]] +name = "alembic" +version = "1.11.1" +description = "A database migration tool for SQLAlchemy." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "alembic-1.11.1-py3-none-any.whl", hash = "sha256:dc871798a601fab38332e38d6ddb38d5e734f60034baeb8e2db5b642fccd8ab8"}, + {file = "alembic-1.11.1.tar.gz", hash = "sha256:6a810a6b012c88b33458fceb869aef09ac75d6ace5291915ba7fae44de372c01"}, +] + +[package.dependencies] +Mako = "*" +SQLAlchemy = ">=1.3.0" +typing-extensions = ">=4" + +[package.extras] +tz = ["python-dateutil"] + +[[package]] +name = "amqp" +version = "5.1.1" +description = "Low-level AMQP client for Python (fork of amqplib)." +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "amqp-5.1.1-py3-none-any.whl", hash = "sha256:6f0956d2c23d8fa6e7691934d8c3930eadb44972cbbd1a7ae3a520f735d43359"}, + {file = "amqp-5.1.1.tar.gz", hash = "sha256:2c1b13fecc0893e946c65cbd5f36427861cffa4ea2201d8f6fca22e2a373b5e2"}, +] + +[package.dependencies] +vine = ">=5.0.0" + +[[package]] +name = "anyio" +version = "3.7.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "anyio-3.7.0-py3-none-any.whl", hash = "sha256:eddca883c4175f14df8aedce21054bfca3adb70ffe76a9f607aef9d7fa2ea7f0"}, + {file = "anyio-3.7.0.tar.gz", hash = "sha256:275d9973793619a5374e1c89a4f4ad3f4b0a5510a2b5b939444bee8f4c4d37ce"}, +] + +[package.dependencies] +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +idna = ">=2.8" +sniffio = ">=1.1" + +[package.extras] +doc = ["Sphinx (>=6.1.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme", "sphinxcontrib-jquery"] +test = ["anyio[trio]", "coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "mock (>=4)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] +trio = ["trio (<0.22)"] + +[[package]] +name = "async-timeout" +version = "4.0.2" +description = "Timeout context manager for asyncio programs" +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "async-timeout-4.0.2.tar.gz", hash = "sha256:2163e1640ddb52b7a8c80d0a67a08587e5d245cc9c553a74a847056bc2976b15"}, + {file = "async_timeout-4.0.2-py3-none-any.whl", hash = "sha256:8ca1e4fcf50d07413d66d1a5e416e42cfdf5851c981d679a09851a6853383b3c"}, +] + +[[package]] +name = "asyncpg" +version = "0.27.0" +description = "An asyncio PostgreSQL driver" +category = "main" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "asyncpg-0.27.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fca608d199ffed4903dce1bcd97ad0fe8260f405c1c225bdf0002709132171c2"}, + {file = "asyncpg-0.27.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:20b596d8d074f6f695c13ffb8646d0b6bb1ab570ba7b0cfd349b921ff03cfc1e"}, + {file = "asyncpg-0.27.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a6206210c869ebd3f4eb9e89bea132aefb56ff3d1b7dd7e26b102b17e27bbb1"}, + {file = "asyncpg-0.27.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7a94c03386bb95456b12c66026b3a87d1b965f0f1e5733c36e7229f8f137747"}, + {file = "asyncpg-0.27.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bfc3980b4ba6f97138b04f0d32e8af21d6c9fa1f8e6e140c07d15690a0a99279"}, + {file = "asyncpg-0.27.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:9654085f2b22f66952124de13a8071b54453ff972c25c59b5ce1173a4283ffd9"}, + {file = "asyncpg-0.27.0-cp310-cp310-win32.whl", hash = "sha256:879c29a75969eb2722f94443752f4720d560d1e748474de54ae8dd230bc4956b"}, + {file = "asyncpg-0.27.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab0f21c4818d46a60ca789ebc92327d6d874d3b7ccff3963f7af0a21dc6cff52"}, + {file = "asyncpg-0.27.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:18f77e8e71e826ba2d0c3ba6764930776719ae2b225ca07e014590545928b576"}, + {file = "asyncpg-0.27.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2232d4625c558f2aa001942cac1d7952aa9f0dbfc212f63bc754277769e1ef2"}, + {file = "asyncpg-0.27.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9a3a4ff43702d39e3c97a8786314123d314e0f0e4dabc8367db5b665c93914de"}, + {file = "asyncpg-0.27.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccddb9419ab4e1c48742457d0c0362dbdaeb9b28e6875115abfe319b29ee225d"}, + {file = "asyncpg-0.27.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:768e0e7c2898d40b16d4ef7a0b44e8150db3dd8995b4652aa1fe2902e92c7df8"}, + {file = "asyncpg-0.27.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:609054a1f47292a905582a1cfcca51a6f3f30ab9d822448693e66fdddde27920"}, + {file = "asyncpg-0.27.0-cp311-cp311-win32.whl", hash = "sha256:8113e17cfe236dc2277ec844ba9b3d5312f61bd2fdae6d3ed1c1cdd75f6cf2d8"}, + {file = "asyncpg-0.27.0-cp311-cp311-win_amd64.whl", hash = "sha256:bb71211414dd1eeb8d31ec529fe77cff04bf53efc783a5f6f0a32d84923f45cf"}, + {file = "asyncpg-0.27.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4750f5cf49ed48a6e49c6e5aed390eee367694636c2dcfaf4a273ca832c5c43c"}, + {file = "asyncpg-0.27.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:eca01eb112a39d31cc4abb93a5aef2a81514c23f70956729f42fb83b11b3483f"}, + {file = "asyncpg-0.27.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:5710cb0937f696ce303f5eed6d272e3f057339bb4139378ccecafa9ee923a71c"}, + {file = "asyncpg-0.27.0-cp37-cp37m-win_amd64.whl", hash = "sha256:71cca80a056ebe19ec74b7117b09e650990c3ca535ac1c35234a96f65604192f"}, + {file = "asyncpg-0.27.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4bb366ae34af5b5cabc3ac6a5347dfb6013af38c68af8452f27968d49085ecc0"}, + {file = "asyncpg-0.27.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16ba8ec2e85d586b4a12bcd03e8d29e3d99e832764d6a1d0b8c27dbbe4a2569d"}, + {file = "asyncpg-0.27.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d20dea7b83651d93b1eb2f353511fe7fd554752844523f17ad30115d8b9c8cd6"}, + {file = "asyncpg-0.27.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e56ac8a8237ad4adec97c0cd4728596885f908053ab725e22900b5902e7f8e69"}, + {file = "asyncpg-0.27.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bf21ebf023ec67335258e0f3d3ad7b91bb9507985ba2b2206346de488267cad0"}, + {file = "asyncpg-0.27.0-cp38-cp38-win32.whl", hash = "sha256:69aa1b443a182b13a17ff926ed6627af2d98f62f2fe5890583270cc4073f63bf"}, + {file = "asyncpg-0.27.0-cp38-cp38-win_amd64.whl", hash = "sha256:62932f29cf2433988fcd799770ec64b374a3691e7902ecf85da14d5e0854d1ea"}, + {file = "asyncpg-0.27.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fddcacf695581a8d856654bc4c8cfb73d5c9df26d5f55201722d3e6a699e9629"}, + {file = "asyncpg-0.27.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7d8585707ecc6661d07367d444bbaa846b4e095d84451340da8df55a3757e152"}, + {file = "asyncpg-0.27.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:975a320baf7020339a67315284a4d3bf7460e664e484672bd3e71dbd881bc692"}, + {file = "asyncpg-0.27.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2232ebae9796d4600a7819fc383da78ab51b32a092795f4555575fc934c1c89d"}, + {file = "asyncpg-0.27.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:88b62164738239f62f4af92567b846a8ef7cf8abf53eddd83650603de4d52163"}, + {file = "asyncpg-0.27.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:eb4b2fdf88af4fb1cc569781a8f933d2a73ee82cd720e0cb4edabbaecf2a905b"}, + {file = "asyncpg-0.27.0-cp39-cp39-win32.whl", hash = "sha256:8934577e1ed13f7d2d9cea3cc016cc6f95c19faedea2c2b56a6f94f257cea672"}, + {file = "asyncpg-0.27.0-cp39-cp39-win_amd64.whl", hash = "sha256:1b6499de06fe035cf2fa932ec5617ed3f37d4ebbf663b655922e105a484a6af9"}, + {file = "asyncpg-0.27.0.tar.gz", hash = "sha256:720986d9a4705dd8a40fdf172036f5ae787225036a7eb46e704c45aa8f62c054"}, +] + +[package.extras] +dev = ["Cython (>=0.29.24,<0.30.0)", "Sphinx (>=4.1.2,<4.2.0)", "flake8 (>=5.0.4,<5.1.0)", "pytest (>=6.0)", "sphinx-rtd-theme (>=0.5.2,<0.6.0)", "sphinxcontrib-asyncio (>=0.3.0,<0.4.0)", "uvloop (>=0.15.3)"] +docs = ["Sphinx (>=4.1.2,<4.2.0)", "sphinx-rtd-theme (>=0.5.2,<0.6.0)", "sphinxcontrib-asyncio (>=0.3.0,<0.4.0)"] +test = ["flake8 (>=5.0.4,<5.1.0)", "uvloop (>=0.15.3)"] + +[[package]] +name = "asynctest" +version = "0.13.0" +description = "Enhance the standard unittest package with features for testing asyncio libraries" +category = "dev" +optional = false +python-versions = ">=3.5" +files = [ + {file = "asynctest-0.13.0-py3-none-any.whl", hash = "sha256:5da6118a7e6d6b54d83a8f7197769d046922a44d2a99c21382f0a6e4fadae676"}, + {file = "asynctest-0.13.0.tar.gz", hash = "sha256:c27862842d15d83e6a34eb0b2866c323880eb3a75e4485b079ea11748fd77fac"}, +] + +[[package]] +name = "atomicwrites" +version = "1.4.1" +description = "Atomic file writes." +category = "dev" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11"}, +] + +[[package]] +name = "attrs" +version = "23.1.0" +description = "Classes Without Boilerplate" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.1.0-py3-none-any.whl", hash = "sha256:1f28b4522cdc2fb4256ac1a020c78acf9cba2c6b461ccd2c126f3aa8e8335d04"}, + {file = "attrs-23.1.0.tar.gz", hash = "sha256:6279836d581513a26f1bf235f9acd333bc9115683f14f7e8fae46c98fc50e015"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[docs,tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-no-zope = ["cloudpickle", "hypothesis", "mypy (>=1.1.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] + +[[package]] +name = "bandit" +version = "1.7.5" +description = "Security oriented static analyser for python code." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "bandit-1.7.5-py3-none-any.whl", hash = "sha256:75665181dc1e0096369112541a056c59d1c5f66f9bb74a8d686c3c362b83f549"}, + {file = "bandit-1.7.5.tar.gz", hash = "sha256:bdfc739baa03b880c2d15d0431b31c658ffc348e907fe197e54e0389dd59e11e"}, +] + +[package.dependencies] +colorama = {version = ">=0.3.9", markers = "platform_system == \"Windows\""} +GitPython = ">=1.0.1" +PyYAML = ">=5.3.1" +rich = "*" +stevedore = ">=1.20.0" + +[package.extras] +test = ["beautifulsoup4 (>=4.8.0)", "coverage (>=4.5.4)", "fixtures (>=3.0.0)", "flake8 (>=4.0.0)", "pylint (==1.9.4)", "stestr (>=2.5.0)", "testscenarios (>=0.5.0)", "testtools (>=2.3.0)", "tomli (>=1.1.0)"] +toml = ["tomli (>=1.1.0)"] +yaml = ["PyYAML"] + +[[package]] +name = "billiard" +version = "4.1.0" +description = "Python multiprocessing fork with improvements and bugfixes" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "billiard-4.1.0-py3-none-any.whl", hash = "sha256:0f50d6be051c6b2b75bfbc8bfd85af195c5739c281d3f5b86a5640c65563614a"}, + {file = "billiard-4.1.0.tar.gz", hash = "sha256:1ad2eeae8e28053d729ba3373d34d9d6e210f6e4d8bf0a9c64f92bd053f1edf5"}, +] + +[[package]] +name = "black" +version = "22.12.0" +description = "The uncompromising code formatter." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "black-22.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eedd20838bd5d75b80c9f5487dbcb06836a43833a37846cf1d8c1cc01cef59d"}, + {file = "black-22.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:159a46a4947f73387b4d83e87ea006dbb2337eab6c879620a3ba52699b1f4351"}, + {file = "black-22.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d30b212bffeb1e252b31dd269dfae69dd17e06d92b87ad26e23890f3efea366f"}, + {file = "black-22.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:7412e75863aa5c5411886804678b7d083c7c28421210180d67dfd8cf1221e1f4"}, + {file = "black-22.12.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c116eed0efb9ff870ded8b62fe9f28dd61ef6e9ddd28d83d7d264a38417dcee2"}, + {file = "black-22.12.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1f58cbe16dfe8c12b7434e50ff889fa479072096d79f0a7f25e4ab8e94cd8350"}, + {file = "black-22.12.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77d86c9f3db9b1bf6761244bc0b3572a546f5fe37917a044e02f3166d5aafa7d"}, + {file = "black-22.12.0-cp38-cp38-win_amd64.whl", hash = "sha256:82d9fe8fee3401e02e79767016b4907820a7dc28d70d137eb397b92ef3cc5bfc"}, + {file = "black-22.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:101c69b23df9b44247bd88e1d7e90154336ac4992502d4197bdac35dd7ee3320"}, + {file = "black-22.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:559c7a1ba9a006226f09e4916060982fd27334ae1998e7a38b3f33a37f7a2148"}, + {file = "black-22.12.0-py3-none-any.whl", hash = "sha256:436cc9167dd28040ad90d3b404aec22cedf24a6e4d7de221bec2730ec0c97bcf"}, + {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""} +typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "boto3" +version = "1.26.158" +description = "The AWS SDK for Python" +category = "main" +optional = false +python-versions = ">= 3.7" +files = [ + {file = "boto3-1.26.158-py3-none-any.whl", hash = "sha256:0be407c2e941b422634766c0d754132ad4d33b5d0f84d9a30426b713b31ce3ab"}, + {file = "boto3-1.26.158.tar.gz", hash = "sha256:7f88d9403f81e6f3fc770c424f7089b15eb0553b168b1d2f979fa0d12b663b42"}, +] + +[package.dependencies] +botocore = ">=1.29.158,<1.30.0" +jmespath = ">=0.7.1,<2.0.0" +s3transfer = ">=0.6.0,<0.7.0" + +[package.extras] +crt = ["botocore[crt] (>=1.21.0,<2.0a0)"] + +[[package]] +name = "botocore" +version = "1.29.158" +description = "Low-level, data-driven core of boto 3." +category = "main" +optional = false +python-versions = ">= 3.7" +files = [ + {file = "botocore-1.29.158-py3-none-any.whl", hash = "sha256:267d4e7f36bdb45ea696386143ca6f68a358dc4baef85894cc4d9cffe97c0cd5"}, + {file = "botocore-1.29.158.tar.gz", hash = "sha256:2fd3b625f3d683d9dd6b400aba54d54a1e9b960b84ed07a466d25d1366e59482"}, +] + +[package.dependencies] +jmespath = ">=0.7.1,<2.0.0" +python-dateutil = ">=2.1,<3.0.0" +urllib3 = ">=1.25.4,<1.27" + +[package.extras] +crt = ["awscrt (==0.16.9)"] + +[[package]] +name = "celery" +version = "5.3.1" +description = "Distributed Task Queue." +category = "main" +optional = false +python-versions = ">=3.8" +files = [ + {file = "celery-5.3.1-py3-none-any.whl", hash = "sha256:27f8f3f3b58de6e0ab4f174791383bbd7445aff0471a43e99cfd77727940753f"}, + {file = "celery-5.3.1.tar.gz", hash = "sha256:f84d1c21a1520c116c2b7d26593926581191435a03aa74b77c941b93ca1c6210"}, +] + +[package.dependencies] +billiard = ">=4.1.0,<5.0" +click = ">=8.1.2,<9.0" +click-didyoumean = ">=0.3.0" +click-plugins = ">=1.1.1" +click-repl = ">=0.2.0" +kombu = ">=5.3.1,<6.0" +python-dateutil = ">=2.8.2" +tzdata = ">=2022.7" +vine = ">=5.0.0,<6.0" + +[package.extras] +arangodb = ["pyArango (>=2.0.1)"] +auth = ["cryptography (==41.0.1)"] +azureblockblob = ["azure-storage-blob (>=12.15.0)"] +brotli = ["brotli (>=1.0.0)", "brotlipy (>=0.7.0)"] +cassandra = ["cassandra-driver (>=3.25.0,<4)"] +consul = ["python-consul2 (==0.1.5)"] +cosmosdbsql = ["pydocumentdb (==2.3.5)"] +couchbase = ["couchbase (>=3.0.0)"] +couchdb = ["pycouchdb (==1.14.2)"] +django = ["Django (>=2.2.28)"] +dynamodb = ["boto3 (>=1.26.143)"] +elasticsearch = ["elasticsearch (<8.0)"] +eventlet = ["eventlet (>=0.32.0)"] +gevent = ["gevent (>=1.5.0)"] +librabbitmq = ["librabbitmq (>=2.0.0)"] +memcache = ["pylibmc (==1.6.3)"] +mongodb = ["pymongo[srv] (>=4.0.2)"] +msgpack = ["msgpack (==1.0.5)"] +pymemcache = ["python-memcached (==1.59)"] +pyro = ["pyro4 (==4.82)"] +pytest = ["pytest-celery (==0.0.0)"] +redis = ["redis (>=4.5.2,!=4.5.5)"] +s3 = ["boto3 (>=1.26.143)"] +slmq = ["softlayer-messaging (>=1.0.3)"] +solar = ["ephem (==4.1.4)"] +sqlalchemy = ["sqlalchemy (>=1.4.48,<2.1)"] +sqs = ["boto3 (>=1.26.143)", "kombu[sqs] (>=5.3.0)", "pycurl (>=7.43.0.5)", "urllib3 (>=1.26.16)"] +tblib = ["tblib (>=1.3.0)", "tblib (>=1.5.0)"] +yaml = ["PyYAML (>=3.10)"] +zookeeper = ["kazoo (>=1.3.1)"] +zstd = ["zstandard (==0.21.0)"] + +[[package]] +name = "certifi" +version = "2023.5.7" +description = "Python package for providing Mozilla's CA Bundle." +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2023.5.7-py3-none-any.whl", hash = "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"}, + {file = "certifi-2023.5.7.tar.gz", hash = "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7"}, +] + +[[package]] +name = "cffi" +version = "1.15.1" +description = "Foreign Function Interface for Python calling C code." +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "cffi-1.15.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2"}, + {file = "cffi-1.15.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2"}, + {file = "cffi-1.15.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:9ad5db27f9cabae298d151c85cf2bad1d359a1b9c686a275df03385758e2f914"}, + {file = "cffi-1.15.1-cp27-cp27m-win32.whl", hash = "sha256:b3bbeb01c2b273cca1e1e0c5df57f12dce9a4dd331b4fa1635b8bec26350bde3"}, + {file = "cffi-1.15.1-cp27-cp27m-win_amd64.whl", hash = "sha256:e00b098126fd45523dd056d2efba6c5a63b71ffe9f2bbe1a4fe1716e1d0c331e"}, + {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:d61f4695e6c866a23a21acab0509af1cdfd2c013cf256bbf5b6b5e2695827162"}, + {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:ed9cb427ba5504c1dc15ede7d516b84757c3e3d7868ccc85121d9310d27eed0b"}, + {file = "cffi-1.15.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21"}, + {file = "cffi-1.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185"}, + {file = "cffi-1.15.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd"}, + {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc"}, + {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f"}, + {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e"}, + {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4"}, + {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01"}, + {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e"}, + {file = "cffi-1.15.1-cp310-cp310-win32.whl", hash = "sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2"}, + {file = "cffi-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d"}, + {file = "cffi-1.15.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac"}, + {file = "cffi-1.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83"}, + {file = "cffi-1.15.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9"}, + {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c"}, + {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325"}, + {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c"}, + {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef"}, + {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8"}, + {file = "cffi-1.15.1-cp311-cp311-win32.whl", hash = "sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d"}, + {file = "cffi-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104"}, + {file = "cffi-1.15.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50a74364d85fd319352182ef59c5c790484a336f6db772c1a9231f1c3ed0cbd7"}, + {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e263d77ee3dd201c3a142934a086a4450861778baaeeb45db4591ef65550b0a6"}, + {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cec7d9412a9102bdc577382c3929b337320c4c4c4849f2c5cdd14d7368c5562d"}, + {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4289fc34b2f5316fbb762d75362931e351941fa95fa18789191b33fc4cf9504a"}, + {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:173379135477dc8cac4bc58f45db08ab45d228b3363adb7af79436135d028405"}, + {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:6975a3fac6bc83c4a65c9f9fcab9e47019a11d3d2cf7f3c0d03431bf145a941e"}, + {file = "cffi-1.15.1-cp36-cp36m-win32.whl", hash = "sha256:2470043b93ff09bf8fb1d46d1cb756ce6132c54826661a32d4e4d132e1977adf"}, + {file = "cffi-1.15.1-cp36-cp36m-win_amd64.whl", hash = "sha256:30d78fbc8ebf9c92c9b7823ee18eb92f2e6ef79b45ac84db507f52fbe3ec4497"}, + {file = "cffi-1.15.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375"}, + {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e"}, + {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82"}, + {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b"}, + {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c"}, + {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426"}, + {file = "cffi-1.15.1-cp37-cp37m-win32.whl", hash = "sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9"}, + {file = "cffi-1.15.1-cp37-cp37m-win_amd64.whl", hash = "sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045"}, + {file = "cffi-1.15.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3"}, + {file = "cffi-1.15.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a"}, + {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5"}, + {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca"}, + {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02"}, + {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192"}, + {file = "cffi-1.15.1-cp38-cp38-win32.whl", hash = "sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314"}, + {file = "cffi-1.15.1-cp38-cp38-win_amd64.whl", hash = "sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5"}, + {file = "cffi-1.15.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585"}, + {file = "cffi-1.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0"}, + {file = "cffi-1.15.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415"}, + {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d"}, + {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984"}, + {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35"}, + {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27"}, + {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76"}, + {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3"}, + {file = "cffi-1.15.1-cp39-cp39-win32.whl", hash = "sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee"}, + {file = "cffi-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c"}, + {file = "cffi-1.15.1.tar.gz", hash = "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "charset-normalizer" +version = "3.1.0" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +category = "main" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"}, + {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"}, + {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"}, + {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"}, + {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"}, + {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"}, + {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"}, +] + +[[package]] +name = "click" +version = "8.1.3" +description = "Composable command line interface toolkit" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, + {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "click-didyoumean" +version = "0.3.0" +description = "Enables git-like *did-you-mean* feature in click" +category = "main" +optional = false +python-versions = ">=3.6.2,<4.0.0" +files = [ + {file = "click-didyoumean-0.3.0.tar.gz", hash = "sha256:f184f0d851d96b6d29297354ed981b7dd71df7ff500d82fa6d11f0856bee8035"}, + {file = "click_didyoumean-0.3.0-py3-none-any.whl", hash = "sha256:a0713dc7a1de3f06bc0df5a9567ad19ead2d3d5689b434768a6145bff77c0667"}, +] + +[package.dependencies] +click = ">=7" + +[[package]] +name = "click-plugins" +version = "1.1.1" +description = "An extension module for click to enable registering CLI commands via setuptools entry-points." +category = "main" +optional = false +python-versions = "*" +files = [ + {file = "click-plugins-1.1.1.tar.gz", hash = "sha256:46ab999744a9d831159c3411bb0c79346d94a444df9a3a3742e9ed63645f264b"}, + {file = "click_plugins-1.1.1-py2.py3-none-any.whl", hash = "sha256:5d262006d3222f5057fd81e1623d4443e41dcda5dc815c06b442aa3c02889fc8"}, +] + +[package.dependencies] +click = ">=4.0" + +[package.extras] +dev = ["coveralls", "pytest (>=3.6)", "pytest-cov", "wheel"] + +[[package]] +name = "click-repl" +version = "0.3.0" +description = "REPL plugin for Click" +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "click-repl-0.3.0.tar.gz", hash = "sha256:17849c23dba3d667247dc4defe1757fff98694e90fe37474f3feebb69ced26a9"}, + {file = "click_repl-0.3.0-py3-none-any.whl", hash = "sha256:fb7e06deb8da8de86180a33a9da97ac316751c094c6899382da7feeeeb51b812"}, +] + +[package.dependencies] +click = ">=7.0" +prompt-toolkit = ">=3.0.36" + +[package.extras] +testing = ["pytest (>=7.2.1)", "pytest-cov (>=4.0.0)", "tox (>=4.4.3)"] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +category = "main" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "coverage" +version = "7.2.7" +description = "Code coverage measurement for Python" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "coverage-7.2.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d39b5b4f2a66ccae8b7263ac3c8170994b65266797fb96cbbfd3fb5b23921db8"}, + {file = "coverage-7.2.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d040ef7c9859bb11dfeb056ff5b3872436e3b5e401817d87a31e1750b9ae2fb"}, + {file = "coverage-7.2.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba90a9563ba44a72fda2e85302c3abc71c5589cea608ca16c22b9804262aaeb6"}, + {file = "coverage-7.2.7-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7d9405291c6928619403db1d10bd07888888ec1abcbd9748fdaa971d7d661b2"}, + {file = "coverage-7.2.7-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31563e97dae5598556600466ad9beea39fb04e0229e61c12eaa206e0aa202063"}, + {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ebba1cd308ef115925421d3e6a586e655ca5a77b5bf41e02eb0e4562a111f2d1"}, + {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cb017fd1b2603ef59e374ba2063f593abe0fc45f2ad9abdde5b4d83bd922a353"}, + {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62a5c7dad11015c66fbb9d881bc4caa5b12f16292f857842d9d1871595f4495"}, + {file = "coverage-7.2.7-cp310-cp310-win32.whl", hash = "sha256:ee57190f24fba796e36bb6d3aa8a8783c643d8fa9760c89f7a98ab5455fbf818"}, + {file = "coverage-7.2.7-cp310-cp310-win_amd64.whl", hash = "sha256:f75f7168ab25dd93110c8a8117a22450c19976afbc44234cbf71481094c1b850"}, + {file = "coverage-7.2.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06a9a2be0b5b576c3f18f1a241f0473575c4a26021b52b2a85263a00f034d51f"}, + {file = "coverage-7.2.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5baa06420f837184130752b7c5ea0808762083bf3487b5038d68b012e5937dbe"}, + {file = "coverage-7.2.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdec9e8cbf13a5bf63290fc6013d216a4c7232efb51548594ca3631a7f13c3a3"}, + {file = "coverage-7.2.7-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52edc1a60c0d34afa421c9c37078817b2e67a392cab17d97283b64c5833f427f"}, + {file = "coverage-7.2.7-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63426706118b7f5cf6bb6c895dc215d8a418d5952544042c8a2d9fe87fcf09cb"}, + {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:afb17f84d56068a7c29f5fa37bfd38d5aba69e3304af08ee94da8ed5b0865833"}, + {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:48c19d2159d433ccc99e729ceae7d5293fbffa0bdb94952d3579983d1c8c9d97"}, + {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0e1f928eaf5469c11e886fe0885ad2bf1ec606434e79842a879277895a50942a"}, + {file = "coverage-7.2.7-cp311-cp311-win32.whl", hash = "sha256:33d6d3ea29d5b3a1a632b3c4e4f4ecae24ef170b0b9ee493883f2df10039959a"}, + {file = "coverage-7.2.7-cp311-cp311-win_amd64.whl", hash = "sha256:5b7540161790b2f28143191f5f8ec02fb132660ff175b7747b95dcb77ac26562"}, + {file = "coverage-7.2.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f2f67fe12b22cd130d34d0ef79206061bfb5eda52feb6ce0dba0644e20a03cf4"}, + {file = "coverage-7.2.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a342242fe22407f3c17f4b499276a02b01e80f861f1682ad1d95b04018e0c0d4"}, + {file = "coverage-7.2.7-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:171717c7cb6b453aebac9a2ef603699da237f341b38eebfee9be75d27dc38e01"}, + {file = "coverage-7.2.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49969a9f7ffa086d973d91cec8d2e31080436ef0fb4a359cae927e742abfaaa6"}, + {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b46517c02ccd08092f4fa99f24c3b83d8f92f739b4657b0f146246a0ca6a831d"}, + {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:a3d33a6b3eae87ceaefa91ffdc130b5e8536182cd6dfdbfc1aa56b46ff8c86de"}, + {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:976b9c42fb2a43ebf304fa7d4a310e5f16cc99992f33eced91ef6f908bd8f33d"}, + {file = "coverage-7.2.7-cp312-cp312-win32.whl", hash = "sha256:8de8bb0e5ad103888d65abef8bca41ab93721647590a3f740100cd65c3b00511"}, + {file = "coverage-7.2.7-cp312-cp312-win_amd64.whl", hash = "sha256:9e31cb64d7de6b6f09702bb27c02d1904b3aebfca610c12772452c4e6c21a0d3"}, + {file = "coverage-7.2.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:58c2ccc2f00ecb51253cbe5d8d7122a34590fac9646a960d1430d5b15321d95f"}, + {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d22656368f0e6189e24722214ed8d66b8022db19d182927b9a248a2a8a2f67eb"}, + {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a895fcc7b15c3fc72beb43cdcbdf0ddb7d2ebc959edac9cef390b0d14f39f8a9"}, + {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e84606b74eb7de6ff581a7915e2dab7a28a0517fbe1c9239eb227e1354064dcd"}, + {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0a5f9e1dbd7fbe30196578ca36f3fba75376fb99888c395c5880b355e2875f8a"}, + {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:419bfd2caae268623dd469eff96d510a920c90928b60f2073d79f8fe2bbc5959"}, + {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2aee274c46590717f38ae5e4650988d1af340fe06167546cc32fe2f58ed05b02"}, + {file = "coverage-7.2.7-cp37-cp37m-win32.whl", hash = "sha256:61b9a528fb348373c433e8966535074b802c7a5d7f23c4f421e6c6e2f1697a6f"}, + {file = "coverage-7.2.7-cp37-cp37m-win_amd64.whl", hash = "sha256:b1c546aca0ca4d028901d825015dc8e4d56aac4b541877690eb76490f1dc8ed0"}, + {file = "coverage-7.2.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:54b896376ab563bd38453cecb813c295cf347cf5906e8b41d340b0321a5433e5"}, + {file = "coverage-7.2.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3d376df58cc111dc8e21e3b6e24606b5bb5dee6024f46a5abca99124b2229ef5"}, + {file = "coverage-7.2.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e330fc79bd7207e46c7d7fd2bb4af2963f5f635703925543a70b99574b0fea9"}, + {file = "coverage-7.2.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e9d683426464e4a252bf70c3498756055016f99ddaec3774bf368e76bbe02b6"}, + {file = "coverage-7.2.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d13c64ee2d33eccf7437961b6ea7ad8673e2be040b4f7fd4fd4d4d28d9ccb1e"}, + {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b7aa5f8a41217360e600da646004f878250a0d6738bcdc11a0a39928d7dc2050"}, + {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8fa03bce9bfbeeef9f3b160a8bed39a221d82308b4152b27d82d8daa7041fee5"}, + {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:245167dd26180ab4c91d5e1496a30be4cd721a5cf2abf52974f965f10f11419f"}, + {file = "coverage-7.2.7-cp38-cp38-win32.whl", hash = "sha256:d2c2db7fd82e9b72937969bceac4d6ca89660db0a0967614ce2481e81a0b771e"}, + {file = "coverage-7.2.7-cp38-cp38-win_amd64.whl", hash = "sha256:2e07b54284e381531c87f785f613b833569c14ecacdcb85d56b25c4622c16c3c"}, + {file = "coverage-7.2.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:537891ae8ce59ef63d0123f7ac9e2ae0fc8b72c7ccbe5296fec45fd68967b6c9"}, + {file = "coverage-7.2.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:06fb182e69f33f6cd1d39a6c597294cff3143554b64b9825d1dc69d18cc2fff2"}, + {file = "coverage-7.2.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:201e7389591af40950a6480bd9edfa8ed04346ff80002cec1a66cac4549c1ad7"}, + {file = "coverage-7.2.7-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f6951407391b639504e3b3be51b7ba5f3528adbf1a8ac3302b687ecababf929e"}, + {file = "coverage-7.2.7-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f48351d66575f535669306aa7d6d6f71bc43372473b54a832222803eb956fd1"}, + {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b29019c76039dc3c0fd815c41392a044ce555d9bcdd38b0fb60fb4cd8e475ba9"}, + {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:81c13a1fc7468c40f13420732805a4c38a105d89848b7c10af65a90beff25250"}, + {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:975d70ab7e3c80a3fe86001d8751f6778905ec723f5b110aed1e450da9d4b7f2"}, + {file = "coverage-7.2.7-cp39-cp39-win32.whl", hash = "sha256:7ee7d9d4822c8acc74a5e26c50604dff824710bc8de424904c0982e25c39c6cb"}, + {file = "coverage-7.2.7-cp39-cp39-win_amd64.whl", hash = "sha256:eb393e5ebc85245347950143969b241d08b52b88a3dc39479822e073a1a8eb27"}, + {file = "coverage-7.2.7-pp37.pp38.pp39-none-any.whl", hash = "sha256:b7b4c971f05e6ae490fef852c218b0e79d4e52f79ef0c8475566584a8fb3e01d"}, + {file = "coverage-7.2.7.tar.gz", hash = "sha256:924d94291ca674905fe9481f12294eb11f2d3d3fd1adb20314ba89e94f44ed59"}, +] + +[package.dependencies] +tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""} + +[package.extras] +toml = ["tomli"] + +[[package]] +name = "cryptography" +version = "41.0.1" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "cryptography-41.0.1-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:f73bff05db2a3e5974a6fd248af2566134d8981fd7ab012e5dd4ddb1d9a70699"}, + {file = "cryptography-41.0.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:1a5472d40c8f8e91ff7a3d8ac6dfa363d8e3138b961529c996f3e2df0c7a411a"}, + {file = "cryptography-41.0.1-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7fa01527046ca5facdf973eef2535a27fec4cb651e4daec4d043ef63f6ecd4ca"}, + {file = "cryptography-41.0.1-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b46e37db3cc267b4dea1f56da7346c9727e1209aa98487179ee8ebed09d21e43"}, + {file = "cryptography-41.0.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d198820aba55660b4d74f7b5fd1f17db3aa5eb3e6893b0a41b75e84e4f9e0e4b"}, + {file = "cryptography-41.0.1-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:948224d76c4b6457349d47c0c98657557f429b4e93057cf5a2f71d603e2fc3a3"}, + {file = "cryptography-41.0.1-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:059e348f9a3c1950937e1b5d7ba1f8e968508ab181e75fc32b879452f08356db"}, + {file = "cryptography-41.0.1-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:b4ceb5324b998ce2003bc17d519080b4ec8d5b7b70794cbd2836101406a9be31"}, + {file = "cryptography-41.0.1-cp37-abi3-win32.whl", hash = "sha256:8f4ab7021127a9b4323537300a2acfb450124b2def3756f64dc3a3d2160ee4b5"}, + {file = "cryptography-41.0.1-cp37-abi3-win_amd64.whl", hash = "sha256:1fee5aacc7367487b4e22484d3c7e547992ed726d14864ee33c0176ae43b0d7c"}, + {file = "cryptography-41.0.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:9a6c7a3c87d595608a39980ebaa04d5a37f94024c9f24eb7d10262b92f739ddb"}, + {file = "cryptography-41.0.1-pp38-pypy38_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5d092fdfedaec4cbbffbf98cddc915ba145313a6fdaab83c6e67f4e6c218e6f3"}, + {file = "cryptography-41.0.1-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a8e6c2de6fbbcc5e14fd27fb24414507cb3333198ea9ab1258d916f00bc3039"}, + {file = "cryptography-41.0.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:cb33ccf15e89f7ed89b235cff9d49e2e62c6c981a6061c9c8bb47ed7951190bc"}, + {file = "cryptography-41.0.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5f0ff6e18d13a3de56f609dd1fd11470918f770c6bd5d00d632076c727d35485"}, + {file = "cryptography-41.0.1-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7bfc55a5eae8b86a287747053140ba221afc65eb06207bedf6e019b8934b477c"}, + {file = "cryptography-41.0.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eb8163f5e549a22888c18b0d53d6bb62a20510060a22fd5a995ec8a05268df8a"}, + {file = "cryptography-41.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8dde71c4169ec5ccc1087bb7521d54251c016f126f922ab2dfe6649170a3b8c5"}, + {file = "cryptography-41.0.1.tar.gz", hash = "sha256:d34579085401d3f49762d2f7d6634d6b6c2ae1242202e860f4d26b046e3a1006"}, +] + +[package.dependencies] +cffi = ">=1.12" + +[package.extras] +docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] +docstest = ["pyenchant (>=1.6.11)", "sphinxcontrib-spelling (>=4.0.1)", "twine (>=1.12.0)"] +nox = ["nox"] +pep8test = ["black", "check-sdist", "mypy", "ruff"] +sdist = ["build"] +ssh = ["bcrypt (>=3.1.5)"] +test = ["pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test-randomorder = ["pytest-randomly"] + +[[package]] +name = "distlib" +version = "0.3.6" +description = "Distribution utilities" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.6-py2.py3-none-any.whl", hash = "sha256:f35c4b692542ca110de7ef0bea44d73981caeb34ca0b9b6b2e6d7790dda8f80e"}, + {file = "distlib-0.3.6.tar.gz", hash = "sha256:14bad2d9b04d3a36127ac97f30b12a19268f211063d8f8ee4f47108896e11b46"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.1.1" +description = "Backport of PEP 654 (exception groups)" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.1.1-py3-none-any.whl", hash = "sha256:232c37c63e4f682982c8b6459f33a8981039e5fb8756b2074364e5055c498c9e"}, + {file = "exceptiongroup-1.1.1.tar.gz", hash = "sha256:d484c3090ba2889ae2928419117447a14daf3c1231d5e30d0aae34f354f01785"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "faker" +version = "16.9.0" +description = "Faker is a Python package that generates fake data for you." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Faker-16.9.0-py3-none-any.whl", hash = "sha256:1f76bd19a642e4af88e8139c6bf764294cfee0172e652d660777e4c570b0699b"}, + {file = "Faker-16.9.0.tar.gz", hash = "sha256:b5dce93b50cd83278b4e6a47b80f0f1ab340f726e27a2b45ba93b814f0612752"}, +] + +[package.dependencies] +python-dateutil = ">=2.4" + +[[package]] +name = "fastapi" +version = "0.87.0" +description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "fastapi-0.87.0-py3-none-any.whl", hash = "sha256:254453a2e22f64e2a1b4e1d8baf67d239e55b6c8165c079d25746a5220c81bb4"}, + {file = "fastapi-0.87.0.tar.gz", hash = "sha256:07032e53df9a57165047b4f38731c38bdcc3be5493220471015e2b4b51b486a4"}, +] + +[package.dependencies] +pydantic = ">=1.6.2,<1.7 || >1.7,<1.7.1 || >1.7.1,<1.7.2 || >1.7.2,<1.7.3 || >1.7.3,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0" +starlette = "0.21.0" + +[package.extras] +all = ["email-validator (>=1.1.1)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "python-multipart (>=0.0.5)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"] +dev = ["pre-commit (>=2.17.0,<3.0.0)", "ruff (==0.0.114)", "uvicorn[standard] (>=0.12.0,<0.19.0)"] +doc = ["mdx-include (>=1.4.1,<2.0.0)", "mkdocs (>=1.1.2,<2.0.0)", "mkdocs-markdownextradata-plugin (>=0.1.7,<0.3.0)", "mkdocs-material (>=8.1.4,<9.0.0)", "pyyaml (>=5.3.1,<7.0.0)", "typer[all] (>=0.6.1,<0.7.0)"] +test = ["anyio[trio] (>=3.2.1,<4.0.0)", "black (==22.8.0)", "coverage[toml] (>=6.5.0,<7.0)", "databases[sqlite] (>=0.3.2,<0.7.0)", "email-validator (>=1.1.1,<2.0.0)", "flask (>=1.1.2,<3.0.0)", "httpx (>=0.23.0,<0.24.0)", "isort (>=5.0.6,<6.0.0)", "mypy (==0.982)", "orjson (>=3.2.1,<4.0.0)", "passlib[bcrypt] (>=1.7.2,<2.0.0)", "peewee (>=3.13.3,<4.0.0)", "pytest (>=7.1.3,<8.0.0)", "python-jose[cryptography] (>=3.3.0,<4.0.0)", "python-multipart (>=0.0.5,<0.0.6)", "pyyaml (>=5.3.1,<7.0.0)", "ruff (==0.0.114)", "sqlalchemy (>=1.3.18,<=1.4.41)", "types-orjson (==3.6.2)", "types-ujson (==5.5.0)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0,<6.0.0)"] + +[[package]] +name = "filelock" +version = "3.12.2" +description = "A platform independent file lock." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "filelock-3.12.2-py3-none-any.whl", hash = "sha256:cbb791cdea2a72f23da6ac5b5269ab0a0d161e9ef0100e653b69049a7706d1ec"}, + {file = "filelock-3.12.2.tar.gz", hash = "sha256:002740518d8aa59a26b0c76e10fb8c6e15eae825d34b6fdf670333fd7b938d81"}, +] + +[package.extras] +docs = ["furo (>=2023.5.20)", "sphinx (>=7.0.1)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "diff-cover (>=7.5)", "pytest (>=7.3.1)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)"] + +[[package]] +name = "flake8" +version = "5.0.4" +description = "the modular source code checker: pep8 pyflakes and co" +category = "dev" +optional = false +python-versions = ">=3.6.1" +files = [ + {file = "flake8-5.0.4-py2.py3-none-any.whl", hash = "sha256:7a1cf6b73744f5806ab95e526f6f0d8c01c66d7bbe349562d22dfca20610b248"}, + {file = "flake8-5.0.4.tar.gz", hash = "sha256:6fbe320aad8d6b95cec8b8e47bc933004678dc63095be98528b7bdd2a9f510db"}, +] + +[package.dependencies] +mccabe = ">=0.7.0,<0.8.0" +pycodestyle = ">=2.9.0,<2.10.0" +pyflakes = ">=2.5.0,<2.6.0" + +[[package]] +name = "frozenlist" +version = "1.3.3" +description = "A list-like structure which implements collections.abc.MutableSequence" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "frozenlist-1.3.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff8bf625fe85e119553b5383ba0fb6aa3d0ec2ae980295aaefa552374926b3f4"}, + {file = "frozenlist-1.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dfbac4c2dfcc082fcf8d942d1e49b6aa0766c19d3358bd86e2000bf0fa4a9cf0"}, + {file = "frozenlist-1.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b1c63e8d377d039ac769cd0926558bb7068a1f7abb0f003e3717ee003ad85530"}, + {file = "frozenlist-1.3.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7fdfc24dcfce5b48109867c13b4cb15e4660e7bd7661741a391f821f23dfdca7"}, + {file = "frozenlist-1.3.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2c926450857408e42f0bbc295e84395722ce74bae69a3b2aa2a65fe22cb14b99"}, + {file = "frozenlist-1.3.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1841e200fdafc3d51f974d9d377c079a0694a8f06de2e67b48150328d66d5483"}, + {file = "frozenlist-1.3.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f470c92737afa7d4c3aacc001e335062d582053d4dbe73cda126f2d7031068dd"}, + {file = "frozenlist-1.3.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:783263a4eaad7c49983fe4b2e7b53fa9770c136c270d2d4bbb6d2192bf4d9caf"}, + {file = "frozenlist-1.3.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:924620eef691990dfb56dc4709f280f40baee568c794b5c1885800c3ecc69816"}, + {file = "frozenlist-1.3.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ae4dc05c465a08a866b7a1baf360747078b362e6a6dbeb0c57f234db0ef88ae0"}, + {file = "frozenlist-1.3.3-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:bed331fe18f58d844d39ceb398b77d6ac0b010d571cba8267c2e7165806b00ce"}, + {file = "frozenlist-1.3.3-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:02c9ac843e3390826a265e331105efeab489ffaf4dd86384595ee8ce6d35ae7f"}, + {file = "frozenlist-1.3.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:9545a33965d0d377b0bc823dcabf26980e77f1b6a7caa368a365a9497fb09420"}, + {file = "frozenlist-1.3.3-cp310-cp310-win32.whl", hash = "sha256:d5cd3ab21acbdb414bb6c31958d7b06b85eeb40f66463c264a9b343a4e238642"}, + {file = "frozenlist-1.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:b756072364347cb6aa5b60f9bc18e94b2f79632de3b0190253ad770c5df17db1"}, + {file = "frozenlist-1.3.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b4395e2f8d83fbe0c627b2b696acce67868793d7d9750e90e39592b3626691b7"}, + {file = "frozenlist-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:14143ae966a6229350021384870458e4777d1eae4c28d1a7aa47f24d030e6678"}, + {file = "frozenlist-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5d8860749e813a6f65bad8285a0520607c9500caa23fea6ee407e63debcdbef6"}, + {file = "frozenlist-1.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23d16d9f477bb55b6154654e0e74557040575d9d19fe78a161bd33d7d76808e8"}, + {file = "frozenlist-1.3.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb82dbba47a8318e75f679690190c10a5e1f447fbf9df41cbc4c3afd726d88cb"}, + {file = "frozenlist-1.3.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9309869032abb23d196cb4e4db574232abe8b8be1339026f489eeb34a4acfd91"}, + {file = "frozenlist-1.3.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a97b4fe50b5890d36300820abd305694cb865ddb7885049587a5678215782a6b"}, + {file = "frozenlist-1.3.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c188512b43542b1e91cadc3c6c915a82a5eb95929134faf7fd109f14f9892ce4"}, + {file = "frozenlist-1.3.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:303e04d422e9b911a09ad499b0368dc551e8c3cd15293c99160c7f1f07b59a48"}, + {file = "frozenlist-1.3.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:0771aed7f596c7d73444c847a1c16288937ef988dc04fb9f7be4b2aa91db609d"}, + {file = "frozenlist-1.3.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:66080ec69883597e4d026f2f71a231a1ee9887835902dbe6b6467d5a89216cf6"}, + {file = "frozenlist-1.3.3-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:41fe21dc74ad3a779c3d73a2786bdf622ea81234bdd4faf90b8b03cad0c2c0b4"}, + {file = "frozenlist-1.3.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f20380df709d91525e4bee04746ba612a4df0972c1b8f8e1e8af997e678c7b81"}, + {file = "frozenlist-1.3.3-cp311-cp311-win32.whl", hash = "sha256:f30f1928162e189091cf4d9da2eac617bfe78ef907a761614ff577ef4edfb3c8"}, + {file = "frozenlist-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:a6394d7dadd3cfe3f4b3b186e54d5d8504d44f2d58dcc89d693698e8b7132b32"}, + {file = "frozenlist-1.3.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8df3de3a9ab8325f94f646609a66cbeeede263910c5c0de0101079ad541af332"}, + {file = "frozenlist-1.3.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0693c609e9742c66ba4870bcee1ad5ff35462d5ffec18710b4ac89337ff16e27"}, + {file = "frozenlist-1.3.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd4210baef299717db0a600d7a3cac81d46ef0e007f88c9335db79f8979c0d3d"}, + {file = "frozenlist-1.3.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:394c9c242113bfb4b9aa36e2b80a05ffa163a30691c7b5a29eba82e937895d5e"}, + {file = "frozenlist-1.3.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6327eb8e419f7d9c38f333cde41b9ae348bec26d840927332f17e887a8dcb70d"}, + {file = "frozenlist-1.3.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e24900aa13212e75e5b366cb9065e78bbf3893d4baab6052d1aca10d46d944c"}, + {file = "frozenlist-1.3.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:3843f84a6c465a36559161e6c59dce2f2ac10943040c2fd021cfb70d58c4ad56"}, + {file = "frozenlist-1.3.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:84610c1502b2461255b4c9b7d5e9c48052601a8957cd0aea6ec7a7a1e1fb9420"}, + {file = "frozenlist-1.3.3-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:c21b9aa40e08e4f63a2f92ff3748e6b6c84d717d033c7b3438dd3123ee18f70e"}, + {file = "frozenlist-1.3.3-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:efce6ae830831ab6a22b9b4091d411698145cb9b8fc869e1397ccf4b4b6455cb"}, + {file = "frozenlist-1.3.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:40de71985e9042ca00b7953c4f41eabc3dc514a2d1ff534027f091bc74416401"}, + {file = "frozenlist-1.3.3-cp37-cp37m-win32.whl", hash = "sha256:180c00c66bde6146a860cbb81b54ee0df350d2daf13ca85b275123bbf85de18a"}, + {file = "frozenlist-1.3.3-cp37-cp37m-win_amd64.whl", hash = "sha256:9bbbcedd75acdfecf2159663b87f1bb5cfc80e7cd99f7ddd9d66eb98b14a8411"}, + {file = "frozenlist-1.3.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:034a5c08d36649591be1cbb10e09da9f531034acfe29275fc5454a3b101ce41a"}, + {file = "frozenlist-1.3.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ba64dc2b3b7b158c6660d49cdb1d872d1d0bf4e42043ad8d5006099479a194e5"}, + {file = "frozenlist-1.3.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:47df36a9fe24054b950bbc2db630d508cca3aa27ed0566c0baf661225e52c18e"}, + {file = "frozenlist-1.3.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:008a054b75d77c995ea26629ab3a0c0d7281341f2fa7e1e85fa6153ae29ae99c"}, + {file = "frozenlist-1.3.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:841ea19b43d438a80b4de62ac6ab21cfe6827bb8a9dc62b896acc88eaf9cecba"}, + {file = "frozenlist-1.3.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e235688f42b36be2b6b06fc37ac2126a73b75fb8d6bc66dd632aa35286238703"}, + {file = "frozenlist-1.3.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca713d4af15bae6e5d79b15c10c8522859a9a89d3b361a50b817c98c2fb402a2"}, + {file = "frozenlist-1.3.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ac5995f2b408017b0be26d4a1d7c61bce106ff3d9e3324374d66b5964325448"}, + {file = "frozenlist-1.3.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a4ae8135b11652b08a8baf07631d3ebfe65a4c87909dbef5fa0cdde440444ee4"}, + {file = "frozenlist-1.3.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:4ea42116ceb6bb16dbb7d526e242cb6747b08b7710d9782aa3d6732bd8d27649"}, + {file = "frozenlist-1.3.3-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:810860bb4bdce7557bc0febb84bbd88198b9dbc2022d8eebe5b3590b2ad6c842"}, + {file = "frozenlist-1.3.3-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:ee78feb9d293c323b59a6f2dd441b63339a30edf35abcb51187d2fc26e696d13"}, + {file = "frozenlist-1.3.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:0af2e7c87d35b38732e810befb9d797a99279cbb85374d42ea61c1e9d23094b3"}, + {file = "frozenlist-1.3.3-cp38-cp38-win32.whl", hash = "sha256:899c5e1928eec13fd6f6d8dc51be23f0d09c5281e40d9cf4273d188d9feeaf9b"}, + {file = "frozenlist-1.3.3-cp38-cp38-win_amd64.whl", hash = "sha256:7f44e24fa70f6fbc74aeec3e971f60a14dde85da364aa87f15d1be94ae75aeef"}, + {file = "frozenlist-1.3.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:2b07ae0c1edaa0a36339ec6cce700f51b14a3fc6545fdd32930d2c83917332cf"}, + {file = "frozenlist-1.3.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ebb86518203e12e96af765ee89034a1dbb0c3c65052d1b0c19bbbd6af8a145e1"}, + {file = "frozenlist-1.3.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5cf820485f1b4c91e0417ea0afd41ce5cf5965011b3c22c400f6d144296ccbc0"}, + {file = "frozenlist-1.3.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c11e43016b9024240212d2a65043b70ed8dfd3b52678a1271972702d990ac6d"}, + {file = "frozenlist-1.3.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8fa3c6e3305aa1146b59a09b32b2e04074945ffcfb2f0931836d103a2c38f936"}, + {file = "frozenlist-1.3.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:352bd4c8c72d508778cf05ab491f6ef36149f4d0cb3c56b1b4302852255d05d5"}, + {file = "frozenlist-1.3.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:65a5e4d3aa679610ac6e3569e865425b23b372277f89b5ef06cf2cdaf1ebf22b"}, + {file = "frozenlist-1.3.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1e2c1185858d7e10ff045c496bbf90ae752c28b365fef2c09cf0fa309291669"}, + {file = "frozenlist-1.3.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f163d2fd041c630fed01bc48d28c3ed4a3b003c00acd396900e11ee5316b56bb"}, + {file = "frozenlist-1.3.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:05cdb16d09a0832eedf770cb7bd1fe57d8cf4eaf5aced29c4e41e3f20b30a784"}, + {file = "frozenlist-1.3.3-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:8bae29d60768bfa8fb92244b74502b18fae55a80eac13c88eb0b496d4268fd2d"}, + {file = "frozenlist-1.3.3-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:eedab4c310c0299961ac285591acd53dc6723a1ebd90a57207c71f6e0c2153ab"}, + {file = "frozenlist-1.3.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3bbdf44855ed8f0fbcd102ef05ec3012d6a4fd7c7562403f76ce6a52aeffb2b1"}, + {file = "frozenlist-1.3.3-cp39-cp39-win32.whl", hash = "sha256:efa568b885bca461f7c7b9e032655c0c143d305bf01c30caf6db2854a4532b38"}, + {file = "frozenlist-1.3.3-cp39-cp39-win_amd64.whl", hash = "sha256:cfe33efc9cb900a4c46f91a5ceba26d6df370ffddd9ca386eb1d4f0ad97b9ea9"}, + {file = "frozenlist-1.3.3.tar.gz", hash = "sha256:58bcc55721e8a90b88332d6cd441261ebb22342e238296bb330968952fbb3a6a"}, +] + +[[package]] +name = "gitdb" +version = "4.0.10" +description = "Git Object Database" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "gitdb-4.0.10-py3-none-any.whl", hash = "sha256:c286cf298426064079ed96a9e4a9d39e7f3e9bf15ba60701e95f5492f28415c7"}, + {file = "gitdb-4.0.10.tar.gz", hash = "sha256:6eb990b69df4e15bad899ea868dc46572c3f75339735663b81de79b06f17eb9a"}, +] + +[package.dependencies] +smmap = ">=3.0.1,<6" + +[[package]] +name = "gitpython" +version = "3.1.31" +description = "GitPython is a Python library used to interact with Git repositories" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "GitPython-3.1.31-py3-none-any.whl", hash = "sha256:f04893614f6aa713a60cbbe1e6a97403ef633103cdd0ef5eb6efe0deb98dbe8d"}, + {file = "GitPython-3.1.31.tar.gz", hash = "sha256:8ce3bcf69adfdf7c7d503e78fd3b1c492af782d58893b650adb2ac8912ddd573"}, +] + +[package.dependencies] +gitdb = ">=4.0.1,<5" + +[[package]] +name = "greenlet" +version = "2.0.2" +description = "Lightweight in-process concurrent programming" +category = "main" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*" +files = [ + {file = "greenlet-2.0.2-cp27-cp27m-macosx_10_14_x86_64.whl", hash = "sha256:bdfea8c661e80d3c1c99ad7c3ff74e6e87184895bbaca6ee8cc61209f8b9b85d"}, + {file = "greenlet-2.0.2-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:9d14b83fab60d5e8abe587d51c75b252bcc21683f24699ada8fb275d7712f5a9"}, + {file = "greenlet-2.0.2-cp27-cp27m-win32.whl", hash = "sha256:6c3acb79b0bfd4fe733dff8bc62695283b57949ebcca05ae5c129eb606ff2d74"}, + {file = "greenlet-2.0.2-cp27-cp27m-win_amd64.whl", hash = "sha256:283737e0da3f08bd637b5ad058507e578dd462db259f7f6e4c5c365ba4ee9343"}, + {file = "greenlet-2.0.2-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:d27ec7509b9c18b6d73f2f5ede2622441de812e7b1a80bbd446cb0633bd3d5ae"}, + {file = "greenlet-2.0.2-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:30bcf80dda7f15ac77ba5af2b961bdd9dbc77fd4ac6105cee85b0d0a5fcf74df"}, + {file = "greenlet-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26fbfce90728d82bc9e6c38ea4d038cba20b7faf8a0ca53a9c07b67318d46088"}, + {file = "greenlet-2.0.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9190f09060ea4debddd24665d6804b995a9c122ef5917ab26e1566dcc712ceeb"}, + {file = "greenlet-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d75209eed723105f9596807495d58d10b3470fa6732dd6756595e89925ce2470"}, + {file = "greenlet-2.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3a51c9751078733d88e013587b108f1b7a1fb106d402fb390740f002b6f6551a"}, + {file = "greenlet-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:76ae285c8104046b3a7f06b42f29c7b73f77683df18c49ab5af7983994c2dd91"}, + {file = "greenlet-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:2d4686f195e32d36b4d7cf2d166857dbd0ee9f3d20ae349b6bf8afc8485b3645"}, + {file = "greenlet-2.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c4302695ad8027363e96311df24ee28978162cdcdd2006476c43970b384a244c"}, + {file = "greenlet-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c48f54ef8e05f04d6eff74b8233f6063cb1ed960243eacc474ee73a2ea8573ca"}, + {file = "greenlet-2.0.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a1846f1b999e78e13837c93c778dcfc3365902cfb8d1bdb7dd73ead37059f0d0"}, + {file = "greenlet-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a06ad5312349fec0ab944664b01d26f8d1f05009566339ac6f63f56589bc1a2"}, + {file = "greenlet-2.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:eff4eb9b7eb3e4d0cae3d28c283dc16d9bed6b193c2e1ace3ed86ce48ea8df19"}, + {file = "greenlet-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5454276c07d27a740c5892f4907c86327b632127dd9abec42ee62e12427ff7e3"}, + {file = "greenlet-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:7cafd1208fdbe93b67c7086876f061f660cfddc44f404279c1585bbf3cdc64c5"}, + {file = "greenlet-2.0.2-cp35-cp35m-macosx_10_14_x86_64.whl", hash = "sha256:910841381caba4f744a44bf81bfd573c94e10b3045ee00de0cbf436fe50673a6"}, + {file = "greenlet-2.0.2-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:18a7f18b82b52ee85322d7a7874e676f34ab319b9f8cce5de06067384aa8ff43"}, + {file = "greenlet-2.0.2-cp35-cp35m-win32.whl", hash = "sha256:03a8f4f3430c3b3ff8d10a2a86028c660355ab637cee9333d63d66b56f09d52a"}, + {file = "greenlet-2.0.2-cp35-cp35m-win_amd64.whl", hash = "sha256:4b58adb399c4d61d912c4c331984d60eb66565175cdf4a34792cd9600f21b394"}, + {file = "greenlet-2.0.2-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:703f18f3fda276b9a916f0934d2fb6d989bf0b4fb5a64825260eb9bfd52d78f0"}, + {file = "greenlet-2.0.2-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:32e5b64b148966d9cccc2c8d35a671409e45f195864560829f395a54226408d3"}, + {file = "greenlet-2.0.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2dd11f291565a81d71dab10b7033395b7a3a5456e637cf997a6f33ebdf06f8db"}, + {file = "greenlet-2.0.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e0f72c9ddb8cd28532185f54cc1453f2c16fb417a08b53a855c4e6a418edd099"}, + {file = "greenlet-2.0.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd021c754b162c0fb55ad5d6b9d960db667faad0fa2ff25bb6e1301b0b6e6a75"}, + {file = "greenlet-2.0.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:3c9b12575734155d0c09d6c3e10dbd81665d5c18e1a7c6597df72fd05990c8cf"}, + {file = "greenlet-2.0.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:b9ec052b06a0524f0e35bd8790686a1da006bd911dd1ef7d50b77bfbad74e292"}, + {file = "greenlet-2.0.2-cp36-cp36m-win32.whl", hash = "sha256:dbfcfc0218093a19c252ca8eb9aee3d29cfdcb586df21049b9d777fd32c14fd9"}, + {file = "greenlet-2.0.2-cp36-cp36m-win_amd64.whl", hash = "sha256:9f35ec95538f50292f6d8f2c9c9f8a3c6540bbfec21c9e5b4b751e0a7c20864f"}, + {file = "greenlet-2.0.2-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:d5508f0b173e6aa47273bdc0a0b5ba055b59662ba7c7ee5119528f466585526b"}, + {file = "greenlet-2.0.2-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:f82d4d717d8ef19188687aa32b8363e96062911e63ba22a0cff7802a8e58e5f1"}, + {file = "greenlet-2.0.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9c59a2120b55788e800d82dfa99b9e156ff8f2227f07c5e3012a45a399620b7"}, + {file = "greenlet-2.0.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2780572ec463d44c1d3ae850239508dbeb9fed38e294c68d19a24d925d9223ca"}, + {file = "greenlet-2.0.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:937e9020b514ceedb9c830c55d5c9872abc90f4b5862f89c0887033ae33c6f73"}, + {file = "greenlet-2.0.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:36abbf031e1c0f79dd5d596bfaf8e921c41df2bdf54ee1eed921ce1f52999a86"}, + {file = "greenlet-2.0.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:18e98fb3de7dba1c0a852731c3070cf022d14f0d68b4c87a19cc1016f3bb8b33"}, + {file = "greenlet-2.0.2-cp37-cp37m-win32.whl", hash = "sha256:3f6ea9bd35eb450837a3d80e77b517ea5bc56b4647f5502cd28de13675ee12f7"}, + {file = "greenlet-2.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:7492e2b7bd7c9b9916388d9df23fa49d9b88ac0640db0a5b4ecc2b653bf451e3"}, + {file = "greenlet-2.0.2-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:b864ba53912b6c3ab6bcb2beb19f19edd01a6bfcbdfe1f37ddd1778abfe75a30"}, + {file = "greenlet-2.0.2-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:ba2956617f1c42598a308a84c6cf021a90ff3862eddafd20c3333d50f0edb45b"}, + {file = "greenlet-2.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc3a569657468b6f3fb60587e48356fe512c1754ca05a564f11366ac9e306526"}, + {file = "greenlet-2.0.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8eab883b3b2a38cc1e050819ef06a7e6344d4a990d24d45bc6f2cf959045a45b"}, + {file = "greenlet-2.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acd2162a36d3de67ee896c43effcd5ee3de247eb00354db411feb025aa319857"}, + {file = "greenlet-2.0.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0bf60faf0bc2468089bdc5edd10555bab6e85152191df713e2ab1fcc86382b5a"}, + {file = "greenlet-2.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b0ef99cdbe2b682b9ccbb964743a6aca37905fda5e0452e5ee239b1654d37f2a"}, + {file = "greenlet-2.0.2-cp38-cp38-win32.whl", hash = "sha256:b80f600eddddce72320dbbc8e3784d16bd3fb7b517e82476d8da921f27d4b249"}, + {file = "greenlet-2.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:4d2e11331fc0c02b6e84b0d28ece3a36e0548ee1a1ce9ddde03752d9b79bba40"}, + {file = "greenlet-2.0.2-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:88d9ab96491d38a5ab7c56dd7a3cc37d83336ecc564e4e8816dbed12e5aaefc8"}, + {file = "greenlet-2.0.2-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:561091a7be172ab497a3527602d467e2b3fbe75f9e783d8b8ce403fa414f71a6"}, + {file = "greenlet-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:971ce5e14dc5e73715755d0ca2975ac88cfdaefcaab078a284fea6cfabf866df"}, + {file = "greenlet-2.0.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be4ed120b52ae4d974aa40215fcdfde9194d63541c7ded40ee12eb4dda57b76b"}, + {file = "greenlet-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94c817e84245513926588caf1152e3b559ff794d505555211ca041f032abbb6b"}, + {file = "greenlet-2.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:1a819eef4b0e0b96bb0d98d797bef17dc1b4a10e8d7446be32d1da33e095dbb8"}, + {file = "greenlet-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:7efde645ca1cc441d6dc4b48c0f7101e8d86b54c8530141b09fd31cef5149ec9"}, + {file = "greenlet-2.0.2-cp39-cp39-win32.whl", hash = "sha256:ea9872c80c132f4663822dd2a08d404073a5a9b5ba6155bea72fb2a79d1093b5"}, + {file = "greenlet-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:db1a39669102a1d8d12b57de2bb7e2ec9066a6f2b3da35ae511ff93b01b5d564"}, + {file = "greenlet-2.0.2.tar.gz", hash = "sha256:e7c8dc13af7db097bed64a051d2dd49e9f0af495c26995c00a9ee842690d34c0"}, +] + +[package.extras] +docs = ["Sphinx", "docutils (<0.18)"] +test = ["objgraph", "psutil"] + +[[package]] +name = "h11" +version = "0.14.0" +description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "0.16.3" +description = "A minimal low-level HTTP client." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "httpcore-0.16.3-py3-none-any.whl", hash = "sha256:da1fb708784a938aa084bde4feb8317056c55037247c787bd7e19eb2c2949dc0"}, + {file = "httpcore-0.16.3.tar.gz", hash = "sha256:c5d6f04e2fc530f39e0c077e6a30caa53f1451096120f1f38b954afd0b17c0cb"}, +] + +[package.dependencies] +anyio = ">=3.0,<5.0" +certifi = "*" +h11 = ">=0.13,<0.15" +sniffio = ">=1.0.0,<2.0.0" + +[package.extras] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (>=1.0.0,<2.0.0)"] + +[[package]] +name = "httpx" +version = "0.23.3" +description = "The next generation HTTP client." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "httpx-0.23.3-py3-none-any.whl", hash = "sha256:a211fcce9b1254ea24f0cd6af9869b3d29aba40154e947d2a07bb499b3e310d6"}, + {file = "httpx-0.23.3.tar.gz", hash = "sha256:9818458eb565bb54898ccb9b8b251a28785dd4a55afbc23d0eb410754fe7d0f9"}, +] + +[package.dependencies] +certifi = "*" +httpcore = ">=0.15.0,<0.17.0" +rfc3986 = {version = ">=1.3,<2", extras = ["idna2008"]} +sniffio = "*" + +[package.extras] +brotli = ["brotli", "brotlicffi"] +cli = ["click (>=8.0.0,<9.0.0)", "pygments (>=2.0.0,<3.0.0)", "rich (>=10,<13)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (>=1.0.0,<2.0.0)"] + +[[package]] +name = "idna" +version = "3.4" +description = "Internationalized Domain Names in Applications (IDNA)" +category = "main" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"}, + {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "isort" +version = "5.12.0" +description = "A Python utility / library to sort Python imports." +category = "dev" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "isort-5.12.0-py3-none-any.whl", hash = "sha256:f84c2818376e66cf843d497486ea8fed8700b340f308f076c6fb1229dff318b6"}, + {file = "isort-5.12.0.tar.gz", hash = "sha256:8bef7dde241278824a6d83f44a544709b065191b95b6e50894bdc722fcba0504"}, +] + +[package.extras] +colors = ["colorama (>=0.4.3)"] +pipfile-deprecated-finder = ["pip-shims (>=0.5.2)", "pipreqs", "requirementslib"] +plugins = ["setuptools"] +requirements-deprecated-finder = ["pip-api", "pipreqs"] + +[[package]] +name = "jinja2" +version = "3.1.2" +description = "A very fast and expressive template engine." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, + {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "jmespath" +version = "1.0.1" +description = "JSON Matching Expressions" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980"}, + {file = "jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe"}, +] + +[[package]] +name = "kombu" +version = "5.3.1" +description = "Messaging library for Python." +category = "main" +optional = false +python-versions = ">=3.8" +files = [ + {file = "kombu-5.3.1-py3-none-any.whl", hash = "sha256:48ee589e8833126fd01ceaa08f8a2041334e9f5894e5763c8486a550454551e9"}, + {file = "kombu-5.3.1.tar.gz", hash = "sha256:fbd7572d92c0bf71c112a6b45163153dea5a7b6a701ec16b568c27d0fd2370f2"}, +] + +[package.dependencies] +amqp = ">=5.1.1,<6.0.0" +typing-extensions = {version = "*", markers = "python_version < \"3.10\""} +vine = "*" + +[package.extras] +azureservicebus = ["azure-servicebus (>=7.10.0)"] +azurestoragequeues = ["azure-identity (>=1.12.0)", "azure-storage-queue (>=12.6.0)"] +confluentkafka = ["confluent-kafka (==2.1.1)"] +consul = ["python-consul2"] +librabbitmq = ["librabbitmq (>=2.0.0)"] +mongodb = ["pymongo (>=4.1.1)"] +msgpack = ["msgpack"] +pyro = ["pyro4"] +qpid = ["qpid-python (>=0.26)", "qpid-tools (>=0.26)"] +redis = ["redis (>=4.5.2)"] +slmq = ["softlayer-messaging (>=1.0.3)"] +sqlalchemy = ["sqlalchemy (>=1.4.48,<2.1)"] +sqs = ["boto3 (>=1.26.143)", "pycurl (>=7.43.0.5)", "urllib3 (>=1.26.16)"] +yaml = ["PyYAML (>=3.10)"] +zookeeper = ["kazoo (>=2.8.0)"] + +[[package]] +name = "mako" +version = "1.2.4" +description = "A super-fast templating language that borrows the best ideas from the existing templating languages." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Mako-1.2.4-py3-none-any.whl", hash = "sha256:c97c79c018b9165ac9922ae4f32da095ffd3c4e6872b45eded42926deea46818"}, + {file = "Mako-1.2.4.tar.gz", hash = "sha256:d60a3903dc3bb01a18ad6a89cdbe2e4eadc69c0bc8ef1e3773ba53d44c3f7a34"}, +] + +[package.dependencies] +MarkupSafe = ">=0.9.2" + +[package.extras] +babel = ["Babel"] +lingua = ["lingua"] +testing = ["pytest"] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +description = "Python port of markdown-it. Markdown parsing, done right!" +category = "dev" +optional = false +python-versions = ">=3.8" +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[package.dependencies] +mdurl = ">=0.1,<1.0" + +[package.extras] +benchmarking = ["psutil", "pytest", "pytest-benchmark"] +code-style = ["pre-commit (>=3.0,<4.0)"] +compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] +linkify = ["linkify-it-py (>=1,<3)"] +plugins = ["mdit-py-plugins"] +profiling = ["gprof2dot"] +rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + +[[package]] +name = "markupsafe" +version = "2.1.3" +description = "Safely add untrusted strings to HTML/XML markup." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd0f502fe016460680cd20aaa5a76d241d6f35a1c3350c474bac1273803893fa"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e09031c87a1e51556fdcb46e5bd4f59dfb743061cf93c4d6831bf894f125eb57"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68e78619a61ecf91e76aa3e6e8e33fc4894a2bebe93410754bd28fce0a8a4f9f"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65c1a9bcdadc6c28eecee2c119465aebff8f7a584dd719facdd9e825ec61ab52"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:525808b8019e36eb524b8c68acdd63a37e75714eac50e988180b169d64480a00"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:962f82a3086483f5e5f64dbad880d31038b698494799b097bc59c2edf392fce6"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:aa7bd130efab1c280bed0f45501b7c8795f9fdbeb02e965371bbef3523627779"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c9c804664ebe8f83a211cace637506669e7890fec1b4195b505c214e50dd4eb7"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win32.whl", hash = "sha256:10bbfe99883db80bdbaff2dcf681dfc6533a614f700da1287707e8a5d78a8431"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:1577735524cdad32f9f694208aa75e422adba74f1baee7551620e43a3141f559"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ad9e82fb8f09ade1c3e1b996a6337afac2b8b9e365f926f5a61aacc71adc5b3c"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c0fae6c3be832a0a0473ac912810b2877c8cb9d76ca48de1ed31e1c68386575"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b076b6226fb84157e3f7c971a47ff3a679d837cf338547532ab866c57930dbee"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfce63a9e7834b12b87c64d6b155fdd9b3b96191b6bd334bf37db7ff1fe457f2"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:338ae27d6b8745585f87218a3f23f1512dbf52c26c28e322dbe54bcede54ccb9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e4dd52d80b8c83fdce44e12478ad2e85c64ea965e75d66dbeafb0a3e77308fcc"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:df0be2b576a7abbf737b1575f048c23fb1d769f267ec4358296f31c2479db8f9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5bbe06f8eeafd38e5d0a4894ffec89378b6c6a625ff57e3028921f8ff59318ac"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win32.whl", hash = "sha256:dd15ff04ffd7e05ffcb7fe79f1b98041b8ea30ae9234aed2a9168b5797c3effb"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:134da1eca9ec0ae528110ccc9e48041e0828d79f24121a1a146161103c76e686"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8e254ae696c88d98da6555f5ace2279cf7cd5b3f52be2b5cf97feafe883b58d2"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb0932dc158471523c9637e807d9bfb93e06a95cbf010f1a38b98623b929ef2b"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9402b03f1a1b4dc4c19845e5c749e3ab82d5078d16a2a4c2cd2df62d57bb0707"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca379055a47383d02a5400cb0d110cef0a776fc644cda797db0c5696cfd7e18e"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:b7ff0f54cb4ff66dd38bebd335a38e2c22c41a8ee45aa608efc890ac3e3931bc"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c011a4149cfbcf9f03994ec2edffcb8b1dc2d2aede7ca243746df97a5d41ce48"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:56d9f2ecac662ca1611d183feb03a3fa4406469dafe241673d521dd5ae92a155"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win32.whl", hash = "sha256:8758846a7e80910096950b67071243da3e5a20ed2546e6392603c096778d48e0"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win_amd64.whl", hash = "sha256:787003c0ddb00500e49a10f2844fac87aa6ce977b90b0feaaf9de23c22508b24"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:2ef12179d3a291be237280175b542c07a36e7f60718296278d8593d21ca937d4"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2c1b19b3aaacc6e57b7e25710ff571c24d6c3613a45e905b1fde04d691b98ee0"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8afafd99945ead6e075b973fefa56379c5b5c53fd8937dad92c662da5d8fd5ee"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c41976a29d078bb235fea9b2ecd3da465df42a562910f9022f1a03107bd02be"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d080e0a5eb2529460b30190fcfcc4199bd7f827663f858a226a81bc27beaa97e"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:69c0f17e9f5a7afdf2cc9fb2d1ce6aabdb3bafb7f38017c0b77862bcec2bbad8"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:504b320cd4b7eff6f968eddf81127112db685e81f7e36e75f9f84f0df46041c3"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:42de32b22b6b804f42c5d98be4f7e5e977ecdd9ee9b660fda1a3edf03b11792d"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win32.whl", hash = "sha256:ceb01949af7121f9fc39f7d27f91be8546f3fb112c608bc4029aef0bab86a2a5"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win_amd64.whl", hash = "sha256:1b40069d487e7edb2676d3fbdb2b0829ffa2cd63a2ec26c4938b2d34391b4ecc"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8023faf4e01efadfa183e863fefde0046de576c6f14659e8782065bcece22198"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6b2b56950d93e41f33b4223ead100ea0fe11f8e6ee5f641eb753ce4b77a7042b"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dcdfd0eaf283af041973bff14a2e143b8bd64e069f4c383416ecd79a81aab58"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05fb21170423db021895e1ea1e1f3ab3adb85d1c2333cbc2310f2a26bc77272e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:282c2cb35b5b673bbcadb33a585408104df04f14b2d9b01d4c345a3b92861c2c"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ab4a0df41e7c16a1392727727e7998a467472d0ad65f3ad5e6e765015df08636"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7ef3cb2ebbf91e330e3bb937efada0edd9003683db6b57bb108c4001f37a02ea"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0a4e4a1aff6c7ac4cd55792abf96c915634c2b97e3cc1c7129578aa68ebd754e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win32.whl", hash = "sha256:fec21693218efe39aa7f8599346e90c705afa52c5b31ae019b2e57e8f6542bb2"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win_amd64.whl", hash = "sha256:3fd4abcb888d15a94f32b75d8fd18ee162ca0c064f35b11134be77050296d6ba"}, + {file = "MarkupSafe-2.1.3.tar.gz", hash = "sha256:af598ed32d6ae86f1b747b82783958b1a4ab8f617b06fe68795c7f026abbdcad"}, +] + +[[package]] +name = "mccabe" +version = "0.7.0" +description = "McCabe checker, plugin for flake8" +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, + {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +description = "Markdown URL utilities" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "moto" +version = "4.1.11" +description = "" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "moto-4.1.11-py2.py3-none-any.whl", hash = "sha256:5003126c46ce70fe351ff1cb67dc8d9a5983f403fae13b7628b0fb503d19039e"}, + {file = "moto-4.1.11.tar.gz", hash = "sha256:f3e966ba1460751e19eab5356545813b29c05478b47eb0da445d688949339be2"}, +] + +[package.dependencies] +boto3 = ">=1.9.201" +botocore = ">=1.12.201" +cryptography = ">=3.3.1" +Jinja2 = ">=2.10.1" +python-dateutil = ">=2.1,<3.0.0" +requests = ">=2.5" +responses = ">=0.13.0" +werkzeug = ">=0.5,<2.2.0 || >2.2.0,<2.2.1 || >2.2.1" +xmltodict = "*" + +[package.extras] +all = ["PyYAML (>=5.1)", "aws-xray-sdk (>=0.93,!=0.96)", "cfn-lint (>=0.40.0)", "docker (>=3.0.0)", "ecdsa (!=0.15)", "graphql-core", "jsondiff (>=1.1.2)", "openapi-spec-validator (>=0.2.8)", "py-partiql-parser (==0.3.3)", "pyparsing (>=3.0.7)", "python-jose[cryptography] (>=3.1.0,<4.0.0)", "setuptools", "sshpubkeys (>=3.1.0)"] +apigateway = ["PyYAML (>=5.1)", "ecdsa (!=0.15)", "openapi-spec-validator (>=0.2.8)", "python-jose[cryptography] (>=3.1.0,<4.0.0)"] +apigatewayv2 = ["PyYAML (>=5.1)"] +appsync = ["graphql-core"] +awslambda = ["docker (>=3.0.0)"] +batch = ["docker (>=3.0.0)"] +cloudformation = ["PyYAML (>=5.1)", "aws-xray-sdk (>=0.93,!=0.96)", "cfn-lint (>=0.40.0)", "docker (>=3.0.0)", "ecdsa (!=0.15)", "graphql-core", "jsondiff (>=1.1.2)", "openapi-spec-validator (>=0.2.8)", "py-partiql-parser (==0.3.3)", "pyparsing (>=3.0.7)", "python-jose[cryptography] (>=3.1.0,<4.0.0)", "setuptools", "sshpubkeys (>=3.1.0)"] +cognitoidp = ["ecdsa (!=0.15)", "python-jose[cryptography] (>=3.1.0,<4.0.0)"] +ds = ["sshpubkeys (>=3.1.0)"] +dynamodb = ["docker (>=3.0.0)", "py-partiql-parser (==0.3.3)"] +dynamodbstreams = ["docker (>=3.0.0)", "py-partiql-parser (==0.3.3)"] +ebs = ["sshpubkeys (>=3.1.0)"] +ec2 = ["sshpubkeys (>=3.1.0)"] +efs = ["sshpubkeys (>=3.1.0)"] +eks = ["sshpubkeys (>=3.1.0)"] +glue = ["pyparsing (>=3.0.7)"] +iotdata = ["jsondiff (>=1.1.2)"] +route53resolver = ["sshpubkeys (>=3.1.0)"] +s3 = ["PyYAML (>=5.1)", "py-partiql-parser (==0.3.3)"] +server = ["PyYAML (>=5.1)", "aws-xray-sdk (>=0.93,!=0.96)", "cfn-lint (>=0.40.0)", "docker (>=3.0.0)", "ecdsa (!=0.15)", "flask (!=2.2.0,!=2.2.1)", "flask-cors", "graphql-core", "jsondiff (>=1.1.2)", "openapi-spec-validator (>=0.2.8)", "py-partiql-parser (==0.3.3)", "pyparsing (>=3.0.7)", "python-jose[cryptography] (>=3.1.0,<4.0.0)", "setuptools", "sshpubkeys (>=3.1.0)"] +ssm = ["PyYAML (>=5.1)"] +xray = ["aws-xray-sdk (>=0.93,!=0.96)", "setuptools"] + +[[package]] +name = "multidict" +version = "6.0.4" +description = "multidict implementation" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "multidict-6.0.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b1a97283e0c85772d613878028fec909f003993e1007eafa715b24b377cb9b8"}, + {file = "multidict-6.0.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:eeb6dcc05e911516ae3d1f207d4b0520d07f54484c49dfc294d6e7d63b734171"}, + {file = "multidict-6.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d6d635d5209b82a3492508cf5b365f3446afb65ae7ebd755e70e18f287b0adf7"}, + {file = "multidict-6.0.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c048099e4c9e9d615545e2001d3d8a4380bd403e1a0578734e0d31703d1b0c0b"}, + {file = "multidict-6.0.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ea20853c6dbbb53ed34cb4d080382169b6f4554d394015f1bef35e881bf83547"}, + {file = "multidict-6.0.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:16d232d4e5396c2efbbf4f6d4df89bfa905eb0d4dc5b3549d872ab898451f569"}, + {file = "multidict-6.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36c63aaa167f6c6b04ef2c85704e93af16c11d20de1d133e39de6a0e84582a93"}, + {file = "multidict-6.0.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:64bdf1086b6043bf519869678f5f2757f473dee970d7abf6da91ec00acb9cb98"}, + {file = "multidict-6.0.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:43644e38f42e3af682690876cff722d301ac585c5b9e1eacc013b7a3f7b696a0"}, + {file = "multidict-6.0.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7582a1d1030e15422262de9f58711774e02fa80df0d1578995c76214f6954988"}, + {file = "multidict-6.0.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:ddff9c4e225a63a5afab9dd15590432c22e8057e1a9a13d28ed128ecf047bbdc"}, + {file = "multidict-6.0.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:ee2a1ece51b9b9e7752e742cfb661d2a29e7bcdba2d27e66e28a99f1890e4fa0"}, + {file = "multidict-6.0.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a2e4369eb3d47d2034032a26c7a80fcb21a2cb22e1173d761a162f11e562caa5"}, + {file = "multidict-6.0.4-cp310-cp310-win32.whl", hash = "sha256:574b7eae1ab267e5f8285f0fe881f17efe4b98c39a40858247720935b893bba8"}, + {file = "multidict-6.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:4dcbb0906e38440fa3e325df2359ac6cb043df8e58c965bb45f4e406ecb162cc"}, + {file = "multidict-6.0.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0dfad7a5a1e39c53ed00d2dd0c2e36aed4650936dc18fd9a1826a5ae1cad6f03"}, + {file = "multidict-6.0.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:64da238a09d6039e3bd39bb3aee9c21a5e34f28bfa5aa22518581f910ff94af3"}, + {file = "multidict-6.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ff959bee35038c4624250473988b24f846cbeb2c6639de3602c073f10410ceba"}, + {file = "multidict-6.0.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01a3a55bd90018c9c080fbb0b9f4891db37d148a0a18722b42f94694f8b6d4c9"}, + {file = "multidict-6.0.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c5cb09abb18c1ea940fb99360ea0396f34d46566f157122c92dfa069d3e0e982"}, + {file = "multidict-6.0.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:666daae833559deb2d609afa4490b85830ab0dfca811a98b70a205621a6109fe"}, + {file = "multidict-6.0.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11bdf3f5e1518b24530b8241529d2050014c884cf18b6fc69c0c2b30ca248710"}, + {file = "multidict-6.0.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d18748f2d30f94f498e852c67d61261c643b349b9d2a581131725595c45ec6c"}, + {file = "multidict-6.0.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:458f37be2d9e4c95e2d8866a851663cbc76e865b78395090786f6cd9b3bbf4f4"}, + {file = "multidict-6.0.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:b1a2eeedcead3a41694130495593a559a668f382eee0727352b9a41e1c45759a"}, + {file = "multidict-6.0.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7d6ae9d593ef8641544d6263c7fa6408cc90370c8cb2bbb65f8d43e5b0351d9c"}, + {file = "multidict-6.0.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:5979b5632c3e3534e42ca6ff856bb24b2e3071b37861c2c727ce220d80eee9ed"}, + {file = "multidict-6.0.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dcfe792765fab89c365123c81046ad4103fcabbc4f56d1c1997e6715e8015461"}, + {file = "multidict-6.0.4-cp311-cp311-win32.whl", hash = "sha256:3601a3cece3819534b11d4efc1eb76047488fddd0c85a3948099d5da4d504636"}, + {file = "multidict-6.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:81a4f0b34bd92df3da93315c6a59034df95866014ac08535fc819f043bfd51f0"}, + {file = "multidict-6.0.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:67040058f37a2a51ed8ea8f6b0e6ee5bd78ca67f169ce6122f3e2ec80dfe9b78"}, + {file = "multidict-6.0.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:853888594621e6604c978ce2a0444a1e6e70c8d253ab65ba11657659dcc9100f"}, + {file = "multidict-6.0.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:39ff62e7d0f26c248b15e364517a72932a611a9b75f35b45be078d81bdb86603"}, + {file = "multidict-6.0.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af048912e045a2dc732847d33821a9d84ba553f5c5f028adbd364dd4765092ac"}, + {file = "multidict-6.0.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1e8b901e607795ec06c9e42530788c45ac21ef3aaa11dbd0c69de543bfb79a9"}, + {file = "multidict-6.0.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:62501642008a8b9871ddfccbf83e4222cf8ac0d5aeedf73da36153ef2ec222d2"}, + {file = "multidict-6.0.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:99b76c052e9f1bc0721f7541e5e8c05db3941eb9ebe7b8553c625ef88d6eefde"}, + {file = "multidict-6.0.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:509eac6cf09c794aa27bcacfd4d62c885cce62bef7b2c3e8b2e49d365b5003fe"}, + {file = "multidict-6.0.4-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:21a12c4eb6ddc9952c415f24eef97e3e55ba3af61f67c7bc388dcdec1404a067"}, + {file = "multidict-6.0.4-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:5cad9430ab3e2e4fa4a2ef4450f548768400a2ac635841bc2a56a2052cdbeb87"}, + {file = "multidict-6.0.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ab55edc2e84460694295f401215f4a58597f8f7c9466faec545093045476327d"}, + {file = "multidict-6.0.4-cp37-cp37m-win32.whl", hash = "sha256:5a4dcf02b908c3b8b17a45fb0f15b695bf117a67b76b7ad18b73cf8e92608775"}, + {file = "multidict-6.0.4-cp37-cp37m-win_amd64.whl", hash = "sha256:6ed5f161328b7df384d71b07317f4d8656434e34591f20552c7bcef27b0ab88e"}, + {file = "multidict-6.0.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5fc1b16f586f049820c5c5b17bb4ee7583092fa0d1c4e28b5239181ff9532e0c"}, + {file = "multidict-6.0.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1502e24330eb681bdaa3eb70d6358e818e8e8f908a22a1851dfd4e15bc2f8161"}, + {file = "multidict-6.0.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b692f419760c0e65d060959df05f2a531945af31fda0c8a3b3195d4efd06de11"}, + {file = "multidict-6.0.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45e1ecb0379bfaab5eef059f50115b54571acfbe422a14f668fc8c27ba410e7e"}, + {file = "multidict-6.0.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ddd3915998d93fbcd2566ddf9cf62cdb35c9e093075f862935573d265cf8f65d"}, + {file = "multidict-6.0.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:59d43b61c59d82f2effb39a93c48b845efe23a3852d201ed2d24ba830d0b4cf2"}, + {file = "multidict-6.0.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc8e1d0c705233c5dd0c5e6460fbad7827d5d36f310a0fadfd45cc3029762258"}, + {file = "multidict-6.0.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d6aa0418fcc838522256761b3415822626f866758ee0bc6632c9486b179d0b52"}, + {file = "multidict-6.0.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6748717bb10339c4760c1e63da040f5f29f5ed6e59d76daee30305894069a660"}, + {file = "multidict-6.0.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:4d1a3d7ef5e96b1c9e92f973e43aa5e5b96c659c9bc3124acbbd81b0b9c8a951"}, + {file = "multidict-6.0.4-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4372381634485bec7e46718edc71528024fcdc6f835baefe517b34a33c731d60"}, + {file = "multidict-6.0.4-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:fc35cb4676846ef752816d5be2193a1e8367b4c1397b74a565a9d0389c433a1d"}, + {file = "multidict-6.0.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:4b9d9e4e2b37daddb5c23ea33a3417901fa7c7b3dee2d855f63ee67a0b21e5b1"}, + {file = "multidict-6.0.4-cp38-cp38-win32.whl", hash = "sha256:e41b7e2b59679edfa309e8db64fdf22399eec4b0b24694e1b2104fb789207779"}, + {file = "multidict-6.0.4-cp38-cp38-win_amd64.whl", hash = "sha256:d6c254ba6e45d8e72739281ebc46ea5eb5f101234f3ce171f0e9f5cc86991480"}, + {file = "multidict-6.0.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:16ab77bbeb596e14212e7bab8429f24c1579234a3a462105cda4a66904998664"}, + {file = "multidict-6.0.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc779e9e6f7fda81b3f9aa58e3a6091d49ad528b11ed19f6621408806204ad35"}, + {file = "multidict-6.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4ceef517eca3e03c1cceb22030a3e39cb399ac86bff4e426d4fc6ae49052cc60"}, + {file = "multidict-6.0.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:281af09f488903fde97923c7744bb001a9b23b039a909460d0f14edc7bf59706"}, + {file = "multidict-6.0.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52f2dffc8acaba9a2f27174c41c9e57f60b907bb9f096b36b1a1f3be71c6284d"}, + {file = "multidict-6.0.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b41156839806aecb3641f3208c0dafd3ac7775b9c4c422d82ee2a45c34ba81ca"}, + {file = "multidict-6.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5e3fc56f88cc98ef8139255cf8cd63eb2c586531e43310ff859d6bb3a6b51f1"}, + {file = "multidict-6.0.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8316a77808c501004802f9beebde51c9f857054a0c871bd6da8280e718444449"}, + {file = "multidict-6.0.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f70b98cd94886b49d91170ef23ec5c0e8ebb6f242d734ed7ed677b24d50c82cf"}, + {file = "multidict-6.0.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bf6774e60d67a9efe02b3616fee22441d86fab4c6d335f9d2051d19d90a40063"}, + {file = "multidict-6.0.4-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:e69924bfcdda39b722ef4d9aa762b2dd38e4632b3641b1d9a57ca9cd18f2f83a"}, + {file = "multidict-6.0.4-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:6b181d8c23da913d4ff585afd1155a0e1194c0b50c54fcfe286f70cdaf2b7176"}, + {file = "multidict-6.0.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:52509b5be062d9eafc8170e53026fbc54cf3b32759a23d07fd935fb04fc22d95"}, + {file = "multidict-6.0.4-cp39-cp39-win32.whl", hash = "sha256:27c523fbfbdfd19c6867af7346332b62b586eed663887392cff78d614f9ec313"}, + {file = "multidict-6.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:33029f5734336aa0d4c0384525da0387ef89148dc7191aae00ca5fb23d7aafc2"}, + {file = "multidict-6.0.4.tar.gz", hash = "sha256:3666906492efb76453c0e7b97f2cf459b0682e7402c0489a95484965dbc1da49"}, +] + +[[package]] +name = "mypy" +version = "0.991" +description = "Optional static typing for Python" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mypy-0.991-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7d17e0a9707d0772f4a7b878f04b4fd11f6f5bcb9b3813975a9b13c9332153ab"}, + {file = "mypy-0.991-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0714258640194d75677e86c786e80ccf294972cc76885d3ebbb560f11db0003d"}, + {file = "mypy-0.991-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0c8f3be99e8a8bd403caa8c03be619544bc2c77a7093685dcf308c6b109426c6"}, + {file = "mypy-0.991-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc9ec663ed6c8f15f4ae9d3c04c989b744436c16d26580eaa760ae9dd5d662eb"}, + {file = "mypy-0.991-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4307270436fd7694b41f913eb09210faff27ea4979ecbcd849e57d2da2f65305"}, + {file = "mypy-0.991-cp310-cp310-win_amd64.whl", hash = "sha256:901c2c269c616e6cb0998b33d4adbb4a6af0ac4ce5cd078afd7bc95830e62c1c"}, + {file = "mypy-0.991-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d13674f3fb73805ba0c45eb6c0c3053d218aa1f7abead6e446d474529aafc372"}, + {file = "mypy-0.991-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1c8cd4fb70e8584ca1ed5805cbc7c017a3d1a29fb450621089ffed3e99d1857f"}, + {file = "mypy-0.991-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:209ee89fbb0deed518605edddd234af80506aec932ad28d73c08f1400ef80a33"}, + {file = "mypy-0.991-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37bd02ebf9d10e05b00d71302d2c2e6ca333e6c2a8584a98c00e038db8121f05"}, + {file = "mypy-0.991-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:26efb2fcc6b67e4d5a55561f39176821d2adf88f2745ddc72751b7890f3194ad"}, + {file = "mypy-0.991-cp311-cp311-win_amd64.whl", hash = "sha256:3a700330b567114b673cf8ee7388e949f843b356a73b5ab22dd7cff4742a5297"}, + {file = "mypy-0.991-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:1f7d1a520373e2272b10796c3ff721ea1a0712288cafaa95931e66aa15798813"}, + {file = "mypy-0.991-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:641411733b127c3e0dab94c45af15fea99e4468f99ac88b39efb1ad677da5711"}, + {file = "mypy-0.991-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3d80e36b7d7a9259b740be6d8d906221789b0d836201af4234093cae89ced0cd"}, + {file = "mypy-0.991-cp37-cp37m-win_amd64.whl", hash = "sha256:e62ebaad93be3ad1a828a11e90f0e76f15449371ffeecca4a0a0b9adc99abcef"}, + {file = "mypy-0.991-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b86ce2c1866a748c0f6faca5232059f881cda6dda2a893b9a8373353cfe3715a"}, + {file = "mypy-0.991-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ac6e503823143464538efda0e8e356d871557ef60ccd38f8824a4257acc18d93"}, + {file = "mypy-0.991-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0cca5adf694af539aeaa6ac633a7afe9bbd760df9d31be55ab780b77ab5ae8bf"}, + {file = "mypy-0.991-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12c56bf73cdab116df96e4ff39610b92a348cc99a1307e1da3c3768bbb5b135"}, + {file = "mypy-0.991-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:652b651d42f155033a1967739788c436491b577b6a44e4c39fb340d0ee7f0d70"}, + {file = "mypy-0.991-cp38-cp38-win_amd64.whl", hash = "sha256:4175593dc25d9da12f7de8de873a33f9b2b8bdb4e827a7cae952e5b1a342e243"}, + {file = "mypy-0.991-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:98e781cd35c0acf33eb0295e8b9c55cdbef64fcb35f6d3aa2186f289bed6e80d"}, + {file = "mypy-0.991-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6d7464bac72a85cb3491c7e92b5b62f3dcccb8af26826257760a552a5e244aa5"}, + {file = "mypy-0.991-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c9166b3f81a10cdf9b49f2d594b21b31adadb3d5e9db9b834866c3258b695be3"}, + {file = "mypy-0.991-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8472f736a5bfb159a5e36740847808f6f5b659960115ff29c7cecec1741c648"}, + {file = "mypy-0.991-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e80e758243b97b618cdf22004beb09e8a2de1af481382e4d84bc52152d1c476"}, + {file = "mypy-0.991-cp39-cp39-win_amd64.whl", hash = "sha256:74e259b5c19f70d35fcc1ad3d56499065c601dfe94ff67ae48b85596b9ec1461"}, + {file = "mypy-0.991-py3-none-any.whl", hash = "sha256:de32edc9b0a7e67c2775e574cb061a537660e51210fbf6006b0b36ea695ae9bb"}, + {file = "mypy-0.991.tar.gz", hash = "sha256:3c0165ba8f354a6d9881809ef29f1a9318a236a6d81c690094c5df32107bde06"}, +] + +[package.dependencies] +mypy-extensions = ">=0.4.3" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=3.10" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +install-types = ["pip"] +python2 = ["typed-ast (>=1.4.0,<2)"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +category = "dev" +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "packaging" +version = "21.3" +description = "Core utilities for Python packages" +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"}, + {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"}, +] + +[package.dependencies] +pyparsing = ">=2.0.2,<3.0.5 || >3.0.5" + +[[package]] +name = "pathspec" +version = "0.11.1" +description = "Utility library for gitignore style pattern matching of file paths." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pathspec-0.11.1-py3-none-any.whl", hash = "sha256:d8af70af76652554bd134c22b3e8a1cc46ed7d91edcdd721ef1a0c51a84a5293"}, + {file = "pathspec-0.11.1.tar.gz", hash = "sha256:2798de800fa92780e33acca925945e9a19a133b715067cf165b8866c15a31687"}, +] + +[[package]] +name = "pbr" +version = "5.11.1" +description = "Python Build Reasonableness" +category = "dev" +optional = false +python-versions = ">=2.6" +files = [ + {file = "pbr-5.11.1-py2.py3-none-any.whl", hash = "sha256:567f09558bae2b3ab53cb3c1e2e33e726ff3338e7bae3db5dc954b3a44eef12b"}, + {file = "pbr-5.11.1.tar.gz", hash = "sha256:aefc51675b0b533d56bb5fd1c8c6c0522fe31896679882e1c4c63d5e4a0fccb3"}, +] + +[[package]] +name = "platformdirs" +version = "3.7.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "platformdirs-3.7.0-py3-none-any.whl", hash = "sha256:cfd065ba43133ff103ab3bd10aecb095c2a0035fcd1f07217c9376900d94ba07"}, + {file = "platformdirs-3.7.0.tar.gz", hash = "sha256:87fbf6473e87c078d536980ba970a472422e94f17b752cfad17024c18876d481"}, +] + +[package.extras] +docs = ["furo (>=2023.5.20)", "proselint (>=0.13)", "sphinx (>=7.0.1)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.3.1)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)"] + +[[package]] +name = "pluggy" +version = "1.2.0" +description = "plugin and hook calling mechanisms for python" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849"}, + {file = "pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "polyfactory" +version = "2.3.2" +description = "Mock data generation factories" +category = "dev" +optional = false +python-versions = ">=3.8,<4.0" +files = [ + {file = "polyfactory-2.3.2-py3-none-any.whl", hash = "sha256:00d8fa88b24287f11ca3dfd91a483e32d2a0326ff7a70544a3d28bf9b432cd1e"}, + {file = "polyfactory-2.3.2.tar.gz", hash = "sha256:7285080fced78480983005a713e36601874d7259af6738c3aa10b5e13160b2e7"}, +] + +[package.dependencies] +faker = "*" +typing-extensions = "*" + +[package.extras] +beanie = ["beanie[beanie]", "pydantic[beanie,odmantic,pydantic]"] +msgspec = ["msgspec[msgspec]"] +odmantic = ["odmantic[odmantic]", "pydantic[beanie,odmantic,pydantic]"] +pydantic = ["pydantic[beanie,odmantic,pydantic]"] + +[[package]] +name = "prometheus-client" +version = "0.15.0" +description = "Python client for the Prometheus monitoring system." +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "prometheus_client-0.15.0-py3-none-any.whl", hash = "sha256:db7c05cbd13a0f79975592d112320f2605a325969b270a94b71dcabc47b931d2"}, + {file = "prometheus_client-0.15.0.tar.gz", hash = "sha256:be26aa452490cfcf6da953f9436e95a9f2b4d578ca80094b4458930e5f584ab1"}, +] + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.38" +description = "Library for building powerful interactive command lines in Python" +category = "main" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.38-py3-none-any.whl", hash = "sha256:45ea77a2f7c60418850331366c81cf6b5b9cf4c7fd34616f733c5427e6abbb1f"}, + {file = "prompt_toolkit-3.0.38.tar.gz", hash = "sha256:23ac5d50538a9a38c8bde05fecb47d0b403ecd0662857a86f886f798563d5b9b"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "py" +version = "1.11.0" +description = "library with cross-python path, ini-parsing, io, code, log facilities" +category = "dev" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, + {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, +] + +[[package]] +name = "pyclean" +version = "2.7.3" +description = "Pure Python cross-platform pyclean. Clean up your Python bytecode." +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "pyclean-2.7.3-py3-none-any.whl", hash = "sha256:e0b824d76820ed12f8b3e39e9964dc16df0b4d00027fef59160f7500080aef3f"}, + {file = "pyclean-2.7.3.tar.gz", hash = "sha256:000d37ca483eb8db10c7c996fd141fa76feafdd4cffd3abe47158d2006a0e986"}, +] + +[[package]] +name = "pycodestyle" +version = "2.9.1" +description = "Python style guide checker" +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pycodestyle-2.9.1-py2.py3-none-any.whl", hash = "sha256:d1735fc58b418fd7c5f658d28d943854f8a849b01a5d0a1e6f3f3fdd0166804b"}, + {file = "pycodestyle-2.9.1.tar.gz", hash = "sha256:2c9607871d58c76354b697b42f5d57e1ada7d261c261efac224b664affdc5785"}, +] + +[[package]] +name = "pycparser" +version = "2.21" +description = "C parser in Python" +category = "dev" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, + {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, +] + +[[package]] +name = "pydantic" +version = "1.10.9" +description = "Data validation and settings management using python type hints" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pydantic-1.10.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e692dec4a40bfb40ca530e07805b1208c1de071a18d26af4a2a0d79015b352ca"}, + {file = "pydantic-1.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c52eb595db83e189419bf337b59154bdcca642ee4b2a09e5d7797e41ace783f"}, + {file = "pydantic-1.10.9-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:939328fd539b8d0edf244327398a667b6b140afd3bf7e347cf9813c736211896"}, + {file = "pydantic-1.10.9-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b48d3d634bca23b172f47f2335c617d3fcb4b3ba18481c96b7943a4c634f5c8d"}, + {file = "pydantic-1.10.9-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:f0b7628fb8efe60fe66fd4adadd7ad2304014770cdc1f4934db41fe46cc8825f"}, + {file = "pydantic-1.10.9-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e1aa5c2410769ca28aa9a7841b80d9d9a1c5f223928ca8bec7e7c9a34d26b1d4"}, + {file = "pydantic-1.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:eec39224b2b2e861259d6f3c8b6290d4e0fbdce147adb797484a42278a1a486f"}, + {file = "pydantic-1.10.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d111a21bbbfd85c17248130deac02bbd9b5e20b303338e0dbe0faa78330e37e0"}, + {file = "pydantic-1.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e9aec8627a1a6823fc62fb96480abe3eb10168fd0d859ee3d3b395105ae19a7"}, + {file = "pydantic-1.10.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07293ab08e7b4d3c9d7de4949a0ea571f11e4557d19ea24dd3ae0c524c0c334d"}, + {file = "pydantic-1.10.9-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ee829b86ce984261d99ff2fd6e88f2230068d96c2a582f29583ed602ef3fc2c"}, + {file = "pydantic-1.10.9-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4b466a23009ff5cdd7076eb56aca537c745ca491293cc38e72bf1e0e00de5b91"}, + {file = "pydantic-1.10.9-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7847ca62e581e6088d9000f3c497267868ca2fa89432714e21a4fb33a04d52e8"}, + {file = "pydantic-1.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:7845b31959468bc5b78d7b95ec52fe5be32b55d0d09983a877cca6aedc51068f"}, + {file = "pydantic-1.10.9-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:517a681919bf880ce1dac7e5bc0c3af1e58ba118fd774da2ffcd93c5f96eaece"}, + {file = "pydantic-1.10.9-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67195274fd27780f15c4c372f4ba9a5c02dad6d50647b917b6a92bf00b3d301a"}, + {file = "pydantic-1.10.9-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2196c06484da2b3fded1ab6dbe182bdabeb09f6318b7fdc412609ee2b564c49a"}, + {file = "pydantic-1.10.9-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:6257bb45ad78abacda13f15bde5886efd6bf549dd71085e64b8dcf9919c38b60"}, + {file = "pydantic-1.10.9-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3283b574b01e8dbc982080d8287c968489d25329a463b29a90d4157de4f2baaf"}, + {file = "pydantic-1.10.9-cp37-cp37m-win_amd64.whl", hash = "sha256:5f8bbaf4013b9a50e8100333cc4e3fa2f81214033e05ac5aa44fa24a98670a29"}, + {file = "pydantic-1.10.9-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b9cd67fb763248cbe38f0593cd8611bfe4b8ad82acb3bdf2b0898c23415a1f82"}, + {file = "pydantic-1.10.9-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f50e1764ce9353be67267e7fd0da08349397c7db17a562ad036aa7c8f4adfdb6"}, + {file = "pydantic-1.10.9-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73ef93e5e1d3c8e83f1ff2e7fdd026d9e063c7e089394869a6e2985696693766"}, + {file = "pydantic-1.10.9-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:128d9453d92e6e81e881dd7e2484e08d8b164da5507f62d06ceecf84bf2e21d3"}, + {file = "pydantic-1.10.9-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ad428e92ab68798d9326bb3e5515bc927444a3d71a93b4a2ca02a8a5d795c572"}, + {file = "pydantic-1.10.9-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fab81a92f42d6d525dd47ced310b0c3e10c416bbfae5d59523e63ea22f82b31e"}, + {file = "pydantic-1.10.9-cp38-cp38-win_amd64.whl", hash = "sha256:963671eda0b6ba6926d8fc759e3e10335e1dc1b71ff2a43ed2efd6996634dafb"}, + {file = "pydantic-1.10.9-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:970b1bdc6243ef663ba5c7e36ac9ab1f2bfecb8ad297c9824b542d41a750b298"}, + {file = "pydantic-1.10.9-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7e1d5290044f620f80cf1c969c542a5468f3656de47b41aa78100c5baa2b8276"}, + {file = "pydantic-1.10.9-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83fcff3c7df7adff880622a98022626f4f6dbce6639a88a15a3ce0f96466cb60"}, + {file = "pydantic-1.10.9-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0da48717dc9495d3a8f215e0d012599db6b8092db02acac5e0d58a65248ec5bc"}, + {file = "pydantic-1.10.9-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:0a2aabdc73c2a5960e87c3ffebca6ccde88665616d1fd6d3db3178ef427b267a"}, + {file = "pydantic-1.10.9-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9863b9420d99dfa9c064042304868e8ba08e89081428a1c471858aa2af6f57c4"}, + {file = "pydantic-1.10.9-cp39-cp39-win_amd64.whl", hash = "sha256:e7c9900b43ac14110efa977be3da28931ffc74c27e96ee89fbcaaf0b0fe338e1"}, + {file = "pydantic-1.10.9-py3-none-any.whl", hash = "sha256:6cafde02f6699ce4ff643417d1a9223716ec25e228ddc3b436fe7e2d25a1f305"}, + {file = "pydantic-1.10.9.tar.gz", hash = "sha256:95c70da2cd3b6ddf3b9645ecaa8d98f3d80c606624b6d245558d202cd23ea3be"}, +] + +[package.dependencies] +typing-extensions = ">=4.2.0" + +[package.extras] +dotenv = ["python-dotenv (>=0.10.4)"] +email = ["email-validator (>=1.0.3)"] + +[[package]] +name = "pyflakes" +version = "2.5.0" +description = "passive checker of Python programs" +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pyflakes-2.5.0-py2.py3-none-any.whl", hash = "sha256:4579f67d887f804e67edb544428f264b7b24f435b263c4614f384135cea553d2"}, + {file = "pyflakes-2.5.0.tar.gz", hash = "sha256:491feb020dca48ccc562a8c0cbe8df07ee13078df59813b83959cbdada312ea3"}, +] + +[[package]] +name = "pygments" +version = "2.15.1" +description = "Pygments is a syntax highlighting package written in Python." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Pygments-2.15.1-py3-none-any.whl", hash = "sha256:db2db3deb4b4179f399a09054b023b6a586b76499d36965813c71aa8ed7b5fd1"}, + {file = "Pygments-2.15.1.tar.gz", hash = "sha256:8ace4d3c1dd481894b2005f560ead0f9f19ee64fe983366be1a21e171d12775c"}, +] + +[package.extras] +plugins = ["importlib-metadata"] + +[[package]] +name = "pyparsing" +version = "3.1.0" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +category = "dev" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.0-py3-none-any.whl", hash = "sha256:d554a96d1a7d3ddaf7183104485bc19fd80543ad6ac5bdb6426719d766fb06c1"}, + {file = "pyparsing-3.1.0.tar.gz", hash = "sha256:edb662d6fe322d6e990b1594b5feaeadf806803359e3d4d42f11e295e588f0ea"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "pytest" +version = "6.2.5" +description = "pytest: simple powerful testing with Python" +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pytest-6.2.5-py3-none-any.whl", hash = "sha256:7310f8d27bc79ced999e760ca304d69f6ba6c6649c0b60fb0e04a4a77cacc134"}, + {file = "pytest-6.2.5.tar.gz", hash = "sha256:131b36680866a76e6781d13f101efb86cf674ebb9762eb70d3082b6f29889e89"}, +] + +[package.dependencies] +atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""} +attrs = ">=19.2.0" +colorama = {version = "*", markers = "sys_platform == \"win32\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" +py = ">=1.8.2" +toml = "*" + +[package.extras] +testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "requests", "xmlschema"] + +[[package]] +name = "pytest-asyncio" +version = "0.16.0" +description = "Pytest support for asyncio." +category = "dev" +optional = false +python-versions = ">= 3.6" +files = [ + {file = "pytest-asyncio-0.16.0.tar.gz", hash = "sha256:7496c5977ce88c34379df64a66459fe395cd05543f0a2f837016e7144391fcfb"}, + {file = "pytest_asyncio-0.16.0-py3-none-any.whl", hash = "sha256:5f2a21273c47b331ae6aa5b36087047b4899e40f03f18397c0e65fa5cca54e9b"}, +] + +[package.dependencies] +pytest = ">=5.4.0" + +[package.extras] +testing = ["coverage", "hypothesis (>=5.7.1)"] + +[[package]] +name = "pytest-celery" +version = "0.0.0" +description = "pytest-celery a shim pytest plugin to enable celery.contrib.pytest" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "pytest-celery-0.0.0.tar.gz", hash = "sha256:cfd060fc32676afa1e4f51b2938f903f7f75d952186b8c6cf631628c4088f406"}, + {file = "pytest_celery-0.0.0-py2.py3-none-any.whl", hash = "sha256:63dec132df3a839226ecb003ffdbb0c2cb88dd328550957e979c942766578060"}, +] + +[package.dependencies] +celery = ">=4.4.0" + +[[package]] +name = "pytest-cov" +version = "3.0.0" +description = "Pytest plugin for measuring coverage." +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pytest-cov-3.0.0.tar.gz", hash = "sha256:e7f0f5b1617d2210a2cabc266dfe2f4c75a8d32fb89eafb7ad9d06f6d076d470"}, + {file = "pytest_cov-3.0.0-py3-none-any.whl", hash = "sha256:578d5d15ac4a25e5f961c938b85a05b09fdaae9deef3bb6de9a6e766622ca7a6"}, +] + +[package.dependencies] +coverage = {version = ">=5.2.1", extras = ["toml"]} +pytest = ">=4.6" + +[package.extras] +testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtualenv"] + +[[package]] +name = "pytest-dotenv" +version = "0.5.2" +description = "A py.test plugin that parses environment files before running tests" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "pytest-dotenv-0.5.2.tar.gz", hash = "sha256:2dc6c3ac6d8764c71c6d2804e902d0ff810fa19692e95fe138aefc9b1aa73732"}, + {file = "pytest_dotenv-0.5.2-py3-none-any.whl", hash = "sha256:40a2cece120a213898afaa5407673f6bd924b1fa7eafce6bda0e8abffe2f710f"}, +] + +[package.dependencies] +pytest = ">=5.0.0" +python-dotenv = ">=0.9.1" + +[[package]] +name = "python-dateutil" +version = "2.8.2" +description = "Extensions to the standard Python datetime module" +category = "main" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, + {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "python-dotenv" +version = "1.0.0" +description = "Read key-value pairs from a .env file and set them as environment variables" +category = "dev" +optional = false +python-versions = ">=3.8" +files = [ + {file = "python-dotenv-1.0.0.tar.gz", hash = "sha256:a8df96034aae6d2d50a4ebe8216326c61c3eb64836776504fcca410e5937a3ba"}, + {file = "python_dotenv-1.0.0-py3-none-any.whl", hash = "sha256:f5971a9226b701070a4bf2c38c89e5a3f0d64de8debda981d1db98583009122a"}, +] + +[package.extras] +cli = ["click (>=5.0)"] + +[[package]] +name = "python-slugify" +version = "7.0.0" +description = "A Python slugify application that also handles Unicode" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "python-slugify-7.0.0.tar.gz", hash = "sha256:7a0f21a39fa6c1c4bf2e5984c9b9ae944483fd10b54804cb0e23a3ccd4954f0b"}, + {file = "python_slugify-7.0.0-py2.py3-none-any.whl", hash = "sha256:003aee64f9fd955d111549f96c4b58a3f40b9319383c70fad6277a4974bbf570"}, +] + +[package.dependencies] +text-unidecode = ">=1.3" + +[package.extras] +unidecode = ["Unidecode (>=1.1.1)"] + +[[package]] +name = "pyyaml" +version = "6.0" +description = "YAML parser and emitter for Python" +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"}, + {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"}, + {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"}, + {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"}, + {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"}, + {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"}, + {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"}, + {file = "PyYAML-6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d4b0ba9512519522b118090257be113b9468d804b19d63c71dbcf4a48fa32358"}, + {file = "PyYAML-6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:81957921f441d50af23654aa6c5e5eaf9b06aba7f0a19c18a538dc7ef291c5a1"}, + {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afa17f5bc4d1b10afd4466fd3a44dc0e245382deca5b3c353d8b757f9e3ecb8d"}, + {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dbad0e9d368bb989f4515da330b88a057617d16b6a8245084f1b05400f24609f"}, + {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:432557aa2c09802be39460360ddffd48156e30721f5e8d917f01d31694216782"}, + {file = "PyYAML-6.0-cp311-cp311-win32.whl", hash = "sha256:bfaef573a63ba8923503d27530362590ff4f576c626d86a9fed95822a8255fd7"}, + {file = "PyYAML-6.0-cp311-cp311-win_amd64.whl", hash = "sha256:01b45c0191e6d66c470b6cf1b9531a771a83c1c4208272ead47a3ae4f2f603bf"}, + {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"}, + {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"}, + {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"}, + {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"}, + {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"}, + {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"}, + {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"}, + {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"}, + {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"}, + {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"}, + {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"}, + {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"}, + {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"}, + {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"}, + {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"}, + {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"}, + {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"}, + {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"}, + {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"}, + {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"}, + {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"}, + {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"}, + {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"}, + {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"}, + {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"}, + {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"}, +] + +[[package]] +name = "redis" +version = "4.5.5" +description = "Python client for Redis database and key-value store" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "redis-4.5.5-py3-none-any.whl", hash = "sha256:77929bc7f5dab9adf3acba2d3bb7d7658f1e0c2f1cafe7eb36434e751c471119"}, + {file = "redis-4.5.5.tar.gz", hash = "sha256:dc87a0bdef6c8bfe1ef1e1c40be7034390c2ae02d92dcd0c7ca1729443899880"}, +] + +[package.dependencies] +async-timeout = {version = ">=4.0.2", markers = "python_full_version <= \"3.11.2\""} + +[package.extras] +hiredis = ["hiredis (>=1.0.0)"] +ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==20.0.1)", "requests (>=2.26.0)"] + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "responses" +version = "0.23.1" +description = "A utility library for mocking out the `requests` Python library." +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "responses-0.23.1-py3-none-any.whl", hash = "sha256:8a3a5915713483bf353b6f4079ba8b2a29029d1d1090a503c70b0dc5d9d0c7bd"}, + {file = "responses-0.23.1.tar.gz", hash = "sha256:c4d9aa9fc888188f0c673eff79a8dadbe2e75b7fe879dc80a221a06e0a68138f"}, +] + +[package.dependencies] +pyyaml = "*" +requests = ">=2.22.0,<3.0" +types-PyYAML = "*" +urllib3 = ">=1.25.10" + +[package.extras] +tests = ["coverage (>=6.0.0)", "flake8", "mypy", "pytest (>=7.0.0)", "pytest-asyncio", "pytest-cov", "pytest-httpserver", "tomli", "tomli-w", "types-requests"] + +[[package]] +name = "respx" +version = "0.19.3" +description = "A utility for mocking out the Python HTTPX and HTTP Core libraries." +category = "dev" +optional = false +python-versions = ">=3.6" +files = [ + {file = "respx-0.19.3-py2.py3-none-any.whl", hash = "sha256:ea3049468bfcf95c7827436230e05b85a037050dc569dbeaecdaa08fa0de5750"}, + {file = "respx-0.19.3.tar.gz", hash = "sha256:6dab3a19dfb0ea07cef996198c12bf8a34e6fc3573a24b184d714f765e8b5e57"}, +] + +[package.dependencies] +httpx = ">=0.21.0" + +[[package]] +name = "rfc3986" +version = "1.5.0" +description = "Validating URI References per RFC 3986" +category = "main" +optional = false +python-versions = "*" +files = [ + {file = "rfc3986-1.5.0-py2.py3-none-any.whl", hash = "sha256:a86d6e1f5b1dc238b218b012df0aa79409667bb209e58da56d0b94704e712a97"}, + {file = "rfc3986-1.5.0.tar.gz", hash = "sha256:270aaf10d87d0d4e095063c65bf3ddbc6ee3d0b226328ce21e036f946e421835"}, +] + +[package.dependencies] +idna = {version = "*", optional = true, markers = "extra == \"idna2008\""} + +[package.extras] +idna2008 = ["idna"] + +[[package]] +name = "rich" +version = "13.4.2" +description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +category = "dev" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "rich-13.4.2-py3-none-any.whl", hash = "sha256:8f87bc7ee54675732fa66a05ebfe489e27264caeeff3728c945d25971b6485ec"}, + {file = "rich-13.4.2.tar.gz", hash = "sha256:d653d6bccede5844304c605d5aac802c7cf9621efd700b46c7ec2b51ea914898"}, +] + +[package.dependencies] +markdown-it-py = ">=2.2.0" +pygments = ">=2.13.0,<3.0.0" + +[package.extras] +jupyter = ["ipywidgets (>=7.5.1,<9)"] + +[[package]] +name = "s3transfer" +version = "0.6.1" +description = "An Amazon S3 Transfer Manager" +category = "main" +optional = false +python-versions = ">= 3.7" +files = [ + {file = "s3transfer-0.6.1-py3-none-any.whl", hash = "sha256:3c0da2d074bf35d6870ef157158641178a4204a6e689e82546083e31e0311346"}, + {file = "s3transfer-0.6.1.tar.gz", hash = "sha256:640bb492711f4c0c0905e1f62b6aaeb771881935ad27884852411f8e9cacbca9"}, +] + +[package.dependencies] +botocore = ">=1.12.36,<2.0a.0" + +[package.extras] +crt = ["botocore[crt] (>=1.20.29,<2.0a.0)"] + +[[package]] +name = "sentry-sdk" +version = "1.25.1" +description = "Python client for Sentry (https://sentry.io)" +category = "main" +optional = false +python-versions = "*" +files = [ + {file = "sentry-sdk-1.25.1.tar.gz", hash = "sha256:aa796423eb6a2f4a8cd7a5b02ba6558cb10aab4ccdc0537f63a47b038c520c38"}, + {file = "sentry_sdk-1.25.1-py2.py3-none-any.whl", hash = "sha256:79afb7c896014038e358401ad1d36889f97a129dfa8031c49b3f238cd1aa3935"}, +] + +[package.dependencies] +certifi = "*" +urllib3 = {version = ">=1.26.11", markers = "python_version >= \"3.6\""} + +[package.extras] +aiohttp = ["aiohttp (>=3.5)"] +arq = ["arq (>=0.23)"] +beam = ["apache-beam (>=2.12)"] +bottle = ["bottle (>=0.12.13)"] +celery = ["celery (>=3)"] +chalice = ["chalice (>=1.16.0)"] +django = ["django (>=1.8)"] +falcon = ["falcon (>=1.4)"] +fastapi = ["fastapi (>=0.79.0)"] +flask = ["blinker (>=1.1)", "flask (>=0.11)", "markupsafe"] +grpcio = ["grpcio (>=1.21.1)"] +httpx = ["httpx (>=0.16.0)"] +huey = ["huey (>=2)"] +loguru = ["loguru (>=0.5)"] +opentelemetry = ["opentelemetry-distro (>=0.35b0)"] +pure-eval = ["asttokens", "executing", "pure-eval"] +pymongo = ["pymongo (>=3.1)"] +pyspark = ["pyspark (>=2.4.4)"] +quart = ["blinker (>=1.1)", "quart (>=0.16.1)"] +rq = ["rq (>=0.6)"] +sanic = ["sanic (>=0.8)"] +sqlalchemy = ["sqlalchemy (>=1.2)"] +starlette = ["starlette (>=0.19.1)"] +starlite = ["starlite (>=1.48)"] +tornado = ["tornado (>=5)"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "slack-sdk" +version = "3.21.3" +description = "The Slack API Platform SDK for Python" +category = "main" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "slack_sdk-3.21.3-py2.py3-none-any.whl", hash = "sha256:de3c07b92479940b61cd68c566f49fbc9974c8f38f661d26244078f3903bb9cc"}, + {file = "slack_sdk-3.21.3.tar.gz", hash = "sha256:20829bdc1a423ec93dac903470975ebf3bc76fd3fd91a4dadc0eeffc940ecb0c"}, +] + +[package.extras] +optional = ["SQLAlchemy (>=1.4,<3)", "aiodns (>1.0)", "aiohttp (>=3.7.3,<4)", "boto3 (<=2)", "websocket-client (>=1,<2)", "websockets (>=10,<11)"] +testing = ["Flask (>=1,<2)", "Flask-Sockets (>=0.2,<1)", "Jinja2 (==3.0.3)", "Werkzeug (<2)", "black (==22.8.0)", "boto3 (<=2)", "click (==8.0.4)", "databases (>=0.5)", "flake8 (>=5,<6)", "itsdangerous (==1.1.0)", "moto (>=3,<4)", "psutil (>=5,<6)", "pytest (>=6.2.5,<7)", "pytest-asyncio (<1)", "pytest-cov (>=2,<3)"] + +[[package]] +name = "smmap" +version = "5.0.0" +description = "A pure Python implementation of a sliding window memory map manager" +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "smmap-5.0.0-py3-none-any.whl", hash = "sha256:2aba19d6a040e78d8b09de5c57e96207b09ed71d8e55ce0959eeee6c8e190d94"}, + {file = "smmap-5.0.0.tar.gz", hash = "sha256:c840e62059cd3be204b0c9c9f74be2c09d5648eddd4580d9314c3ecde0b30936"}, +] + +[[package]] +name = "sniffio" +version = "1.3.0" +description = "Sniff out which async library your code is running under" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "sniffio-1.3.0-py3-none-any.whl", hash = "sha256:eecefdce1e5bbfb7ad2eeaabf7c1eeb404d7757c379bd1f7e5cce9d8bf425384"}, + {file = "sniffio-1.3.0.tar.gz", hash = "sha256:e60305c5e5d314f5389259b7f22aaa33d8f7dee49763119234af3755c55b9101"}, +] + +[[package]] +name = "sqlalchemy" +version = "1.4.48" +description = "Database Abstraction Library" +category = "main" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "SQLAlchemy-1.4.48-cp27-cp27m-macosx_10_14_x86_64.whl", hash = "sha256:4bac3aa3c3d8bc7408097e6fe8bf983caa6e9491c5d2e2488cfcfd8106f13b6a"}, + {file = "SQLAlchemy-1.4.48-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:dbcae0e528d755f4522cad5842f0942e54b578d79f21a692c44d91352ea6d64e"}, + {file = "SQLAlchemy-1.4.48-cp27-cp27m-win32.whl", hash = "sha256:cbbe8b8bffb199b225d2fe3804421b7b43a0d49983f81dc654d0431d2f855543"}, + {file = "SQLAlchemy-1.4.48-cp27-cp27m-win_amd64.whl", hash = "sha256:627e04a5d54bd50628fc8734d5fc6df2a1aa5962f219c44aad50b00a6cdcf965"}, + {file = "SQLAlchemy-1.4.48-cp27-cp27mu-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:9af1db7a287ef86e0f5cd990b38da6bd9328de739d17e8864f1817710da2d217"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:ce7915eecc9c14a93b73f4e1c9d779ca43e955b43ddf1e21df154184f39748e5"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5381ddd09a99638f429f4cbe1b71b025bed318f6a7b23e11d65f3eed5e181c33"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:87609f6d4e81a941a17e61a4c19fee57f795e96f834c4f0a30cee725fc3f81d9"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb0808ad34167f394fea21bd4587fc62f3bd81bba232a1e7fbdfa17e6cfa7cd7"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-win32.whl", hash = "sha256:d53cd8bc582da5c1c8c86b6acc4ef42e20985c57d0ebc906445989df566c5603"}, + {file = "SQLAlchemy-1.4.48-cp310-cp310-win_amd64.whl", hash = "sha256:4355e5915844afdc5cf22ec29fba1010166e35dd94a21305f49020022167556b"}, + {file = "SQLAlchemy-1.4.48-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:066c2b0413e8cb980e6d46bf9d35ca83be81c20af688fedaef01450b06e4aa5e"}, + {file = "SQLAlchemy-1.4.48-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c99bf13e07140601d111a7c6f1fc1519914dd4e5228315bbda255e08412f61a4"}, + {file = "SQLAlchemy-1.4.48-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ee26276f12614d47cc07bc85490a70f559cba965fb178b1c45d46ffa8d73fda"}, + {file = "SQLAlchemy-1.4.48-cp311-cp311-win32.whl", hash = "sha256:49c312bcff4728bffc6fb5e5318b8020ed5c8b958a06800f91859fe9633ca20e"}, + {file = "SQLAlchemy-1.4.48-cp311-cp311-win_amd64.whl", hash = "sha256:cef2e2abc06eab187a533ec3e1067a71d7bbec69e582401afdf6d8cad4ba3515"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:3509159e050bd6d24189ec7af373359f07aed690db91909c131e5068176c5a5d"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fc2ab4d9f6d9218a5caa4121bdcf1125303482a1cdcfcdbd8567be8518969c0"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e1ddbbcef9bcedaa370c03771ebec7e39e3944782bef49e69430383c376a250b"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f82d8efea1ca92b24f51d3aea1a82897ed2409868a0af04247c8c1e4fef5890"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-win32.whl", hash = "sha256:e3e98d4907805b07743b583a99ecc58bf8807ecb6985576d82d5e8ae103b5272"}, + {file = "SQLAlchemy-1.4.48-cp36-cp36m-win_amd64.whl", hash = "sha256:25887b4f716e085a1c5162f130b852f84e18d2633942c8ca40dfb8519367c14f"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:0817c181271b0ce5df1aa20949f0a9e2426830fed5ecdcc8db449618f12c2730"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe1dd2562313dd9fe1778ed56739ad5d9aae10f9f43d9f4cf81d65b0c85168bb"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:68413aead943883b341b2b77acd7a7fe2377c34d82e64d1840860247cec7ff7c"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fbde5642104ac6e95f96e8ad6d18d9382aa20672008cf26068fe36f3004491df"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-win32.whl", hash = "sha256:11c6b1de720f816c22d6ad3bbfa2f026f89c7b78a5c4ffafb220e0183956a92a"}, + {file = "SQLAlchemy-1.4.48-cp37-cp37m-win_amd64.whl", hash = "sha256:eb5464ee8d4bb6549d368b578e9529d3c43265007193597ddca71c1bae6174e6"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:92e6133cf337c42bfee03ca08c62ba0f2d9695618c8abc14a564f47503157be9"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44d29a3fc6d9c45962476b470a81983dd8add6ad26fdbfae6d463b509d5adcda"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:005e942b451cad5285015481ae4e557ff4154dde327840ba91b9ac379be3b6ce"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c8cfe951ed074ba5e708ed29c45397a95c4143255b0d022c7c8331a75ae61f3"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-win32.whl", hash = "sha256:2b9af65cc58726129d8414fc1a1a650dcdd594ba12e9c97909f1f57d48e393d3"}, + {file = "SQLAlchemy-1.4.48-cp38-cp38-win_amd64.whl", hash = "sha256:2b562e9d1e59be7833edf28b0968f156683d57cabd2137d8121806f38a9d58f4"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:a1fc046756cf2a37d7277c93278566ddf8be135c6a58397b4c940abf837011f4"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d9b55252d2ca42a09bcd10a697fa041e696def9dfab0b78c0aaea1485551a08"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6dab89874e72a9ab5462997846d4c760cdb957958be27b03b49cf0de5e5c327c"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fd8b5ee5a3acc4371f820934b36f8109ce604ee73cc668c724abb054cebcb6e"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-win32.whl", hash = "sha256:eee09350fd538e29cfe3a496ec6f148504d2da40dbf52adefb0d2f8e4d38ccc4"}, + {file = "SQLAlchemy-1.4.48-cp39-cp39-win_amd64.whl", hash = "sha256:7ad2b0f6520ed5038e795cc2852eb5c1f20fa6831d73301ced4aafbe3a10e1f6"}, + {file = "SQLAlchemy-1.4.48.tar.gz", hash = "sha256:b47bc287096d989a0838ce96f7d8e966914a24da877ed41a7531d44b55cdb8df"}, +] + +[package.dependencies] +greenlet = {version = "!=0.4.17", markers = "python_version >= \"3\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"} + +[package.extras] +aiomysql = ["aiomysql", "greenlet (!=0.4.17)"] +aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing-extensions (!=3.10.0.1)"] +asyncio = ["greenlet (!=0.4.17)"] +asyncmy = ["asyncmy (>=0.2.3,!=0.2.4)", "greenlet (!=0.4.17)"] +mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2)"] +mssql = ["pyodbc"] +mssql-pymssql = ["pymssql"] +mssql-pyodbc = ["pyodbc"] +mypy = ["mypy (>=0.910)", "sqlalchemy2-stubs"] +mysql = ["mysqlclient (>=1.4.0)", "mysqlclient (>=1.4.0,<2)"] +mysql-connector = ["mysql-connector-python"] +oracle = ["cx-oracle (>=7)", "cx-oracle (>=7,<8)"] +postgresql = ["psycopg2 (>=2.7)"] +postgresql-asyncpg = ["asyncpg", "greenlet (!=0.4.17)"] +postgresql-pg8000 = ["pg8000 (>=1.16.6,!=1.29.0)"] +postgresql-psycopg2binary = ["psycopg2-binary"] +postgresql-psycopg2cffi = ["psycopg2cffi"] +pymysql = ["pymysql", "pymysql (<1)"] +sqlcipher = ["sqlcipher3-binary"] + +[[package]] +name = "starlette" +version = "0.21.0" +description = "The little ASGI library that shines." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "starlette-0.21.0-py3-none-any.whl", hash = "sha256:0efc058261bbcddeca93cad577efd36d0c8a317e44376bcfc0e097a2b3dc24a7"}, + {file = "starlette-0.21.0.tar.gz", hash = "sha256:b1b52305ee8f7cfc48cde383496f7c11ab897cd7112b33d998b1317dc8ef9027"}, +] + +[package.dependencies] +anyio = ">=3.4.0,<5" +typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""} + +[package.extras] +full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart", "pyyaml"] + +[[package]] +name = "stevedore" +version = "5.1.0" +description = "Manage dynamic plugins for Python applications" +category = "dev" +optional = false +python-versions = ">=3.8" +files = [ + {file = "stevedore-5.1.0-py3-none-any.whl", hash = "sha256:8cc040628f3cea5d7128f2e76cf486b2251a4e543c7b938f58d9a377f6694a2d"}, + {file = "stevedore-5.1.0.tar.gz", hash = "sha256:a54534acf9b89bc7ed264807013b505bf07f74dbe4bcfa37d32bd063870b087c"}, +] + +[package.dependencies] +pbr = ">=2.0.0,<2.1.0 || >2.1.0" + +[[package]] +name = "text-unidecode" +version = "1.3" +description = "The most basic Text::Unidecode port" +category = "main" +optional = false +python-versions = "*" +files = [ + {file = "text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93"}, + {file = "text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8"}, +] + +[[package]] +name = "toml" +version = "0.10.2" +description = "Python Library for Tom's Obvious, Minimal Language" +category = "main" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, + {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, +] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "tox" +version = "3.28.0" +description = "tox is a generic virtualenv management and test command line tool" +category = "dev" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" +files = [ + {file = "tox-3.28.0-py2.py3-none-any.whl", hash = "sha256:57b5ab7e8bb3074edc3c0c0b4b192a4f3799d3723b2c5b76f1fa9f2d40316eea"}, + {file = "tox-3.28.0.tar.gz", hash = "sha256:d0d28f3fe6d6d7195c27f8b054c3e99d5451952b54abdae673b71609a581f640"}, +] + +[package.dependencies] +colorama = {version = ">=0.4.1", markers = "platform_system == \"Windows\""} +filelock = ">=3.0.0" +packaging = ">=14" +pluggy = ">=0.12.0" +py = ">=1.4.17" +six = ">=1.14.0" +tomli = {version = ">=2.0.1", markers = "python_version >= \"3.7\" and python_version < \"3.11\""} +virtualenv = ">=16.0.0,<20.0.0 || >20.0.0,<20.0.1 || >20.0.1,<20.0.2 || >20.0.2,<20.0.3 || >20.0.3,<20.0.4 || >20.0.4,<20.0.5 || >20.0.5,<20.0.6 || >20.0.6,<20.0.7 || >20.0.7" + +[package.extras] +docs = ["pygments-github-lexers (>=0.0.5)", "sphinx (>=2.0.0)", "sphinxcontrib-autoprogram (>=0.1.5)", "towncrier (>=18.5.0)"] +testing = ["flaky (>=3.4.0)", "freezegun (>=0.3.11)", "pathlib2 (>=2.3.3)", "psutil (>=5.6.1)", "pytest (>=4.0.0)", "pytest-cov (>=2.5.1)", "pytest-mock (>=1.10.0)", "pytest-randomly (>=1.0.0)"] + +[[package]] +name = "types-python-slugify" +version = "7.0.0.1" +description = "Typing stubs for python-slugify" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-python-slugify-7.0.0.1.tar.gz", hash = "sha256:6b2d16e1465896df0e3685bd38eab7b8f945a3a7c18c4a2c2ef391b0e48dfce8"}, + {file = "types_python_slugify-7.0.0.1-py3-none-any.whl", hash = "sha256:3644bb44a25847ba5c8f9d15757f1d4b76064857c30e93517723618bd1152a19"}, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.10" +description = "Typing stubs for PyYAML" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-PyYAML-6.0.12.10.tar.gz", hash = "sha256:ebab3d0700b946553724ae6ca636ea932c1b0868701d4af121630e78d695fc97"}, + {file = "types_PyYAML-6.0.12.10-py3-none-any.whl", hash = "sha256:662fa444963eff9b68120d70cda1af5a5f2aa57900003c2006d7626450eaae5f"}, +] + +[[package]] +name = "types-requests" +version = "2.31.0.1" +description = "Typing stubs for requests" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-requests-2.31.0.1.tar.gz", hash = "sha256:3de667cffa123ce698591de0ad7db034a5317457a596eb0b4944e5a9d9e8d1ac"}, + {file = "types_requests-2.31.0.1-py3-none-any.whl", hash = "sha256:afb06ef8f25ba83d59a1d424bd7a5a939082f94b94e90ab5e6116bd2559deaa3"}, +] + +[package.dependencies] +types-urllib3 = "*" + +[[package]] +name = "types-sqlalchemy" +version = "1.4.53.38" +description = "Typing stubs for SQLAlchemy" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-SQLAlchemy-1.4.53.38.tar.gz", hash = "sha256:5bb7463537e04e1aa5a3557eb725930df99226dcfd3c9bf93008025bfe5c169e"}, + {file = "types_SQLAlchemy-1.4.53.38-py3-none-any.whl", hash = "sha256:7e60e74f823931cc9a9e8adb0a4c05e5533e6708b8a266807893a739faf4eaaa"}, +] + +[[package]] +name = "types-toml" +version = "0.10.8.6" +description = "Typing stubs for toml" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-toml-0.10.8.6.tar.gz", hash = "sha256:6d3ac79e36c9ee593c5d4fb33a50cca0e3adceb6ef5cff8b8e5aef67b4c4aaf2"}, + {file = "types_toml-0.10.8.6-py3-none-any.whl", hash = "sha256:de7b2bb1831d6f7a4b554671ffe5875e729753496961b3e9b202745e4955dafa"}, +] + +[[package]] +name = "types-urllib3" +version = "1.26.25.13" +description = "Typing stubs for urllib3" +category = "dev" +optional = false +python-versions = "*" +files = [ + {file = "types-urllib3-1.26.25.13.tar.gz", hash = "sha256:3300538c9dc11dad32eae4827ac313f5d986b8b21494801f1bf97a1ac6c03ae5"}, + {file = "types_urllib3-1.26.25.13-py3-none-any.whl", hash = "sha256:5dbd1d2bef14efee43f5318b5d36d805a489f6600252bb53626d4bfafd95e27c"}, +] + +[[package]] +name = "typing-extensions" +version = "4.6.3" +description = "Backported and Experimental Type Hints for Python 3.7+" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "typing_extensions-4.6.3-py3-none-any.whl", hash = "sha256:88a4153d8505aabbb4e13aacb7c486c2b4a33ca3b3f807914a9b4c844c471c26"}, + {file = "typing_extensions-4.6.3.tar.gz", hash = "sha256:d91d5919357fe7f681a9f2b5b4cb2a5f1ef0a1e9f59c4d8ff0d3491e05c0ffd5"}, +] + +[[package]] +name = "tzdata" +version = "2023.3" +description = "Provider of IANA time zone data" +category = "main" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2023.3-py2.py3-none-any.whl", hash = "sha256:7e65763eef3120314099b6939b5546db7adce1e7d6f2e179e3df563c70511eda"}, + {file = "tzdata-2023.3.tar.gz", hash = "sha256:11ef1e08e54acb0d4f95bdb1be05da659673de4acbd21bf9c69e94cc5e907a3a"}, +] + +[[package]] +name = "urllib3" +version = "1.26.16" +description = "HTTP library with thread-safe connection pooling, file post, and more." +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +files = [ + {file = "urllib3-1.26.16-py2.py3-none-any.whl", hash = "sha256:8d36afa7616d8ab714608411b4a3b13e58f463aee519024578e062e141dce20f"}, + {file = "urllib3-1.26.16.tar.gz", hash = "sha256:8f135f6502756bde6b2a9b28989df5fbe87c9970cecaa69041edcce7f0589b14"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotlipy (>=0.6.0)"] +secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"] +socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] + +[[package]] +name = "uvicorn" +version = "0.20.0" +description = "The lightning-fast ASGI server." +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uvicorn-0.20.0-py3-none-any.whl", hash = "sha256:c3ed1598a5668208723f2bb49336f4509424ad198d6ab2615b7783db58d919fd"}, + {file = "uvicorn-0.20.0.tar.gz", hash = "sha256:a4e12017b940247f836bc90b72e725d7dfd0c8ed1c51eb365f5ba30d9f5127d8"}, +] + +[package.dependencies] +click = ">=7.0" +h11 = ">=0.8" + +[package.extras] +standard = ["colorama (>=0.4)", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1)", "watchfiles (>=0.13)", "websockets (>=10.4)"] + +[[package]] +name = "vine" +version = "5.0.0" +description = "Promises, promises, promises." +category = "main" +optional = false +python-versions = ">=3.6" +files = [ + {file = "vine-5.0.0-py2.py3-none-any.whl", hash = "sha256:4c9dceab6f76ed92105027c49c823800dd33cacce13bdedc5b914e3514b7fb30"}, + {file = "vine-5.0.0.tar.gz", hash = "sha256:7d3b1624a953da82ef63462013bbd271d3eb75751489f9807598e8f340bd637e"}, +] + +[[package]] +name = "virtualenv" +version = "20.23.1" +description = "Virtual Python Environment builder" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "virtualenv-20.23.1-py3-none-any.whl", hash = "sha256:34da10f14fea9be20e0fd7f04aba9732f84e593dac291b757ce42e3368a39419"}, + {file = "virtualenv-20.23.1.tar.gz", hash = "sha256:8ff19a38c1021c742148edc4f81cb43d7f8c6816d2ede2ab72af5b84c749ade1"}, +] + +[package.dependencies] +distlib = ">=0.3.6,<1" +filelock = ">=3.12,<4" +platformdirs = ">=3.5.1,<4" + +[package.extras] +docs = ["furo (>=2023.5.20)", "proselint (>=0.13)", "sphinx (>=7.0.1)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.3.1)", "pytest-env (>=0.8.1)", "pytest-freezer (>=0.4.6)", "pytest-mock (>=3.10)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=67.8)", "time-machine (>=2.9)"] + +[[package]] +name = "wcwidth" +version = "0.2.6" +description = "Measures the displayed width of unicode strings in a terminal" +category = "main" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.6-py2.py3-none-any.whl", hash = "sha256:795b138f6875577cd91bba52baf9e445cd5118fd32723b460e30a0af30ea230e"}, + {file = "wcwidth-0.2.6.tar.gz", hash = "sha256:a5220780a404dbe3353789870978e472cfe477761f06ee55077256e509b156d0"}, +] + +[[package]] +name = "werkzeug" +version = "2.3.6" +description = "The comprehensive WSGI web application library." +category = "dev" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Werkzeug-2.3.6-py3-none-any.whl", hash = "sha256:935539fa1413afbb9195b24880778422ed620c0fc09670945185cce4d91a8890"}, + {file = "Werkzeug-2.3.6.tar.gz", hash = "sha256:98c774df2f91b05550078891dee5f0eb0cb797a522c757a2452b9cee5b202330"}, +] + +[package.dependencies] +MarkupSafe = ">=2.1.1" + +[package.extras] +watchdog = ["watchdog (>=2.3)"] + +[[package]] +name = "xmltodict" +version = "0.13.0" +description = "Makes working with XML feel like you are working with JSON" +category = "dev" +optional = false +python-versions = ">=3.4" +files = [ + {file = "xmltodict-0.13.0-py2.py3-none-any.whl", hash = "sha256:aa89e8fd76320154a40d19a0df04a4695fb9dc5ba977cbb68ab3e4eb225e7852"}, + {file = "xmltodict-0.13.0.tar.gz", hash = "sha256:341595a488e3e01a85a9d8911d8912fd922ede5fecc4dce437eb4b6c8d037e56"}, +] + +[[package]] +name = "yarl" +version = "1.9.2" +description = "Yet another URL library" +category = "main" +optional = false +python-versions = ">=3.7" +files = [ + {file = "yarl-1.9.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8c2ad583743d16ddbdf6bb14b5cd76bf43b0d0006e918809d5d4ddf7bde8dd82"}, + {file = "yarl-1.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:82aa6264b36c50acfb2424ad5ca537a2060ab6de158a5bd2a72a032cc75b9eb8"}, + {file = "yarl-1.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c0c77533b5ed4bcc38e943178ccae29b9bcf48ffd1063f5821192f23a1bd27b9"}, + {file = "yarl-1.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee4afac41415d52d53a9833ebae7e32b344be72835bbb589018c9e938045a560"}, + {file = "yarl-1.9.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9bf345c3a4f5ba7f766430f97f9cc1320786f19584acc7086491f45524a551ac"}, + {file = "yarl-1.9.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a96c19c52ff442a808c105901d0bdfd2e28575b3d5f82e2f5fd67e20dc5f4ea"}, + {file = "yarl-1.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:891c0e3ec5ec881541f6c5113d8df0315ce5440e244a716b95f2525b7b9f3608"}, + {file = "yarl-1.9.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c3a53ba34a636a256d767c086ceb111358876e1fb6b50dfc4d3f4951d40133d5"}, + {file = "yarl-1.9.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:566185e8ebc0898b11f8026447eacd02e46226716229cea8db37496c8cdd26e0"}, + {file = "yarl-1.9.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:2b0738fb871812722a0ac2154be1f049c6223b9f6f22eec352996b69775b36d4"}, + {file = "yarl-1.9.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:32f1d071b3f362c80f1a7d322bfd7b2d11e33d2adf395cc1dd4df36c9c243095"}, + {file = "yarl-1.9.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:e9fdc7ac0d42bc3ea78818557fab03af6181e076a2944f43c38684b4b6bed8e3"}, + {file = "yarl-1.9.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:56ff08ab5df8429901ebdc5d15941b59f6253393cb5da07b4170beefcf1b2528"}, + {file = "yarl-1.9.2-cp310-cp310-win32.whl", hash = "sha256:8ea48e0a2f931064469bdabca50c2f578b565fc446f302a79ba6cc0ee7f384d3"}, + {file = "yarl-1.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:50f33040f3836e912ed16d212f6cc1efb3231a8a60526a407aeb66c1c1956dde"}, + {file = "yarl-1.9.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:646d663eb2232d7909e6601f1a9107e66f9791f290a1b3dc7057818fe44fc2b6"}, + {file = "yarl-1.9.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aff634b15beff8902d1f918012fc2a42e0dbae6f469fce134c8a0dc51ca423bb"}, + {file = "yarl-1.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a83503934c6273806aed765035716216cc9ab4e0364f7f066227e1aaea90b8d0"}, + {file = "yarl-1.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b25322201585c69abc7b0e89e72790469f7dad90d26754717f3310bfe30331c2"}, + {file = "yarl-1.9.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:22a94666751778629f1ec4280b08eb11815783c63f52092a5953faf73be24191"}, + {file = "yarl-1.9.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ec53a0ea2a80c5cd1ab397925f94bff59222aa3cf9c6da938ce05c9ec20428d"}, + {file = "yarl-1.9.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:159d81f22d7a43e6eabc36d7194cb53f2f15f498dbbfa8edc8a3239350f59fe7"}, + {file = "yarl-1.9.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:832b7e711027c114d79dffb92576acd1bd2decc467dec60e1cac96912602d0e6"}, + {file = "yarl-1.9.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:95d2ecefbcf4e744ea952d073c6922e72ee650ffc79028eb1e320e732898d7e8"}, + {file = "yarl-1.9.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:d4e2c6d555e77b37288eaf45b8f60f0737c9efa3452c6c44626a5455aeb250b9"}, + {file = "yarl-1.9.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:783185c75c12a017cc345015ea359cc801c3b29a2966c2655cd12b233bf5a2be"}, + {file = "yarl-1.9.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:b8cc1863402472f16c600e3e93d542b7e7542a540f95c30afd472e8e549fc3f7"}, + {file = "yarl-1.9.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:822b30a0f22e588b32d3120f6d41e4ed021806418b4c9f0bc3048b8c8cb3f92a"}, + {file = "yarl-1.9.2-cp311-cp311-win32.whl", hash = "sha256:a60347f234c2212a9f0361955007fcf4033a75bf600a33c88a0a8e91af77c0e8"}, + {file = "yarl-1.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:be6b3fdec5c62f2a67cb3f8c6dbf56bbf3f61c0f046f84645cd1ca73532ea051"}, + {file = "yarl-1.9.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:38a3928ae37558bc1b559f67410df446d1fbfa87318b124bf5032c31e3447b74"}, + {file = "yarl-1.9.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac9bb4c5ce3975aeac288cfcb5061ce60e0d14d92209e780c93954076c7c4367"}, + {file = "yarl-1.9.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3da8a678ca8b96c8606bbb8bfacd99a12ad5dd288bc6f7979baddd62f71c63ef"}, + {file = "yarl-1.9.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13414591ff516e04fcdee8dc051c13fd3db13b673c7a4cb1350e6b2ad9639ad3"}, + {file = "yarl-1.9.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf74d08542c3a9ea97bb8f343d4fcbd4d8f91bba5ec9d5d7f792dbe727f88938"}, + {file = "yarl-1.9.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e7221580dc1db478464cfeef9b03b95c5852cc22894e418562997df0d074ccc"}, + {file = "yarl-1.9.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:494053246b119b041960ddcd20fd76224149cfea8ed8777b687358727911dd33"}, + {file = "yarl-1.9.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:52a25809fcbecfc63ac9ba0c0fb586f90837f5425edfd1ec9f3372b119585e45"}, + {file = "yarl-1.9.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:e65610c5792870d45d7b68c677681376fcf9cc1c289f23e8e8b39c1485384185"}, + {file = "yarl-1.9.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:1b1bba902cba32cdec51fca038fd53f8beee88b77efc373968d1ed021024cc04"}, + {file = "yarl-1.9.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:662e6016409828ee910f5d9602a2729a8a57d74b163c89a837de3fea050c7582"}, + {file = "yarl-1.9.2-cp37-cp37m-win32.whl", hash = "sha256:f364d3480bffd3aa566e886587eaca7c8c04d74f6e8933f3f2c996b7f09bee1b"}, + {file = "yarl-1.9.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6a5883464143ab3ae9ba68daae8e7c5c95b969462bbe42e2464d60e7e2698368"}, + {file = "yarl-1.9.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5610f80cf43b6202e2c33ba3ec2ee0a2884f8f423c8f4f62906731d876ef4fac"}, + {file = "yarl-1.9.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b9a4e67ad7b646cd6f0938c7ebfd60e481b7410f574c560e455e938d2da8e0f4"}, + {file = "yarl-1.9.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:83fcc480d7549ccebe9415d96d9263e2d4226798c37ebd18c930fce43dfb9574"}, + {file = "yarl-1.9.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5fcd436ea16fee7d4207c045b1e340020e58a2597301cfbcfdbe5abd2356c2fb"}, + {file = "yarl-1.9.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84e0b1599334b1e1478db01b756e55937d4614f8654311eb26012091be109d59"}, + {file = "yarl-1.9.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3458a24e4ea3fd8930e934c129b676c27452e4ebda80fbe47b56d8c6c7a63a9e"}, + {file = "yarl-1.9.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:838162460b3a08987546e881a2bfa573960bb559dfa739e7800ceeec92e64417"}, + {file = "yarl-1.9.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4e2d08f07a3d7d3e12549052eb5ad3eab1c349c53ac51c209a0e5991bbada78"}, + {file = "yarl-1.9.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de119f56f3c5f0e2fb4dee508531a32b069a5f2c6e827b272d1e0ff5ac040333"}, + {file = "yarl-1.9.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:149ddea5abf329752ea5051b61bd6c1d979e13fbf122d3a1f9f0c8be6cb6f63c"}, + {file = "yarl-1.9.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:674ca19cbee4a82c9f54e0d1eee28116e63bc6fd1e96c43031d11cbab8b2afd5"}, + {file = "yarl-1.9.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:9b3152f2f5677b997ae6c804b73da05a39daa6a9e85a512e0e6823d81cdad7cc"}, + {file = "yarl-1.9.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5415d5a4b080dc9612b1b63cba008db84e908b95848369aa1da3686ae27b6d2b"}, + {file = "yarl-1.9.2-cp38-cp38-win32.whl", hash = "sha256:f7a3d8146575e08c29ed1cd287068e6d02f1c7bdff8970db96683b9591b86ee7"}, + {file = "yarl-1.9.2-cp38-cp38-win_amd64.whl", hash = "sha256:63c48f6cef34e6319a74c727376e95626f84ea091f92c0250a98e53e62c77c72"}, + {file = "yarl-1.9.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75df5ef94c3fdc393c6b19d80e6ef1ecc9ae2f4263c09cacb178d871c02a5ba9"}, + {file = "yarl-1.9.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c027a6e96ef77d401d8d5a5c8d6bc478e8042f1e448272e8d9752cb0aff8b5c8"}, + {file = "yarl-1.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3b078dbe227f79be488ffcfc7a9edb3409d018e0952cf13f15fd6512847f3f7"}, + {file = "yarl-1.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59723a029760079b7d991a401386390c4be5bfec1e7dd83e25a6a0881859e716"}, + {file = "yarl-1.9.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b03917871bf859a81ccb180c9a2e6c1e04d2f6a51d953e6a5cdd70c93d4e5a2a"}, + {file = "yarl-1.9.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c1012fa63eb6c032f3ce5d2171c267992ae0c00b9e164efe4d73db818465fac3"}, + {file = "yarl-1.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a74dcbfe780e62f4b5a062714576f16c2f3493a0394e555ab141bf0d746bb955"}, + {file = "yarl-1.9.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c56986609b057b4839968ba901944af91b8e92f1725d1a2d77cbac6972b9ed1"}, + {file = "yarl-1.9.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2c315df3293cd521033533d242d15eab26583360b58f7ee5d9565f15fee1bef4"}, + {file = "yarl-1.9.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:b7232f8dfbd225d57340e441d8caf8652a6acd06b389ea2d3222b8bc89cbfca6"}, + {file = "yarl-1.9.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:53338749febd28935d55b41bf0bcc79d634881195a39f6b2f767870b72514caf"}, + {file = "yarl-1.9.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:066c163aec9d3d073dc9ffe5dd3ad05069bcb03fcaab8d221290ba99f9f69ee3"}, + {file = "yarl-1.9.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8288d7cd28f8119b07dd49b7230d6b4562f9b61ee9a4ab02221060d21136be80"}, + {file = "yarl-1.9.2-cp39-cp39-win32.whl", hash = "sha256:b124e2a6d223b65ba8768d5706d103280914d61f5cae3afbc50fc3dfcc016623"}, + {file = "yarl-1.9.2-cp39-cp39-win_amd64.whl", hash = "sha256:61016e7d582bc46a5378ffdd02cd0314fb8ba52f40f9cf4d9a5e7dbef88dee18"}, + {file = "yarl-1.9.2.tar.gz", hash = "sha256:04ab9d4b9f587c06d801c2abfe9317b77cdf996c65a90d5e84ecc45010823571"}, +] + +[package.dependencies] +idna = ">=2.0" +multidict = ">=4.0" + +[metadata] +lock-version = "2.0" +python-versions = "^3.9" +content-hash = "69da133b3167391549c097e3805b7ba60ec7b67106e0e9b7f50e6504b5b58737" diff --git a/pyproject.toml b/pyproject.toml new file mode 100755 index 0000000..23b6138 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,106 @@ +[tool.poetry] +name = "security-bot" +version = "0.1.0" +description = "Security Bot" +authors = [ + "Ivan Zhirov ", + "Valerio Rico <5669698+V-Rico@users.noreply.github.com>", +] +license = "MIT" + +[tool.poetry.dependencies] +python = "^3.9" +fastapi = "^0.87.0" +uvicorn = "^0.20.0" +httpx = "^0.23.1" +celery = "^5.2.7" +redis = "^4.3.5" +requests = "^2.28.1" +toml = "^0.10.2" +sentry-sdk = "^1.11.1" +gitpython = "^3.1.29" +yarl = "^1.8.1" +pyyaml = "^6.0" +slack-sdk = "^3.19.4" +python-slugify = "^7.0.0" +sqlalchemy = "^1.4.45" +alembic = "^1.8.1" +prometheus-client = "^0.15.0" +asyncpg = "^0.27.0" +aiohttp = "^3.8.3" +boto3 = "^1.26.91" +pydantic = "^1.10.9" + +[tool.poetry.group.dev.dependencies] +pytest = "^6.2.5" +tox = "^3.24.0" +pytest-asyncio = "^0.16.0" +pytest-cov = "^3.0.0" +black = "^22.10.0" +isort = "^5.10.1" +bandit = "^1.7.0" +mypy = "^0.991" +flake8 = "^5.0.4" +pyclean = "^2.0.0" +packaging = "^21.0" +respx = "^0.19.0" +asynctest = "^0.13.0" +types-requests = "^2.28.11.5" +types-python-slugify = "^7.0.0.1" +types-pyyaml = "^6.0.12.2" +types-toml = "^0.10.8.1" +pytest-dotenv = "^0.5.2" +pytest-celery = "^0.0.0" +types-sqlalchemy = "^1.4.53.19" +greenlet = "^2.0.1" +faker = "^16.7.0" +moto = "^4.1.4" +polyfactory = "^2.3.2" + +[build-system] +requires = ["poetry>=1.1.0"] +build-backend = "poetry.masonry.api" + +[tool.black] +line-length = 87 +target-version = ['py39'] +include = '\.pyi?$' +exclude = 'build\/|buck-out\/|dist\/|_build\/|.git\/|.hg\/|.mypy_cache\/|.tox\/|.venv\/|proto\/|stubs\/|migrations\/' + +[tool.mypy] +ignore_missing_imports = true +warn_return_any = true +warn_redundant_casts = true +warn_unused_configs = true +plugins = ['pydantic.mypy'] +exclude = [ + '.git', + '.mypy_cache', + '.pytest_cache', + '.run', + '.cache', + '.venv', + 'app/alembic' +] + +[tool.isort] +profile = 'black' +line_length = 87 +atomic = true +skip = [ + '.git', + '.mypy_cache', + '.pytest_cache', + '.run', + '.cache', + '.venv', + 'app/alembic' +] + +[tool.mypy-pytest] +ignore_missing_imports = true + +[tool.pytest.ini_options] +python_files = ['tests.py', 'test_*.py', '*_tests.py'] +env_files = '.env.dev' +addopts = ["--cov", "-vv"] diff --git a/static/security-bot-logo.png b/static/security-bot-logo.png new file mode 100755 index 0000000000000000000000000000000000000000..de34d9994d21e4d51e87dd97f8fefe88aa73bafb GIT binary patch literal 68070 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 Y53uL3uOuul>i_@%07*qoM6N<$g5l*g^Z)<= literal 0 HcmV?d00001 diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100755 index 0000000..0afeebd --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,42 @@ +import pytest +from faker import Faker +from pydantic import BaseModel, BaseSettings, SecretStr +from starlette.testclient import TestClient + +from app.main import app # noqa +from tests.units.common import get_test_root_directory + + +@pytest.fixture +def client(): + with TestClient(app) as client: + yield client + + +@pytest.fixture +def dir_tests(): + return get_test_root_directory() + + +@pytest.fixture(scope="session") +def celery_config(): + return {"task_always_eager": True} + + +@pytest.fixture +def example_settings(): + class ExampleModel(BaseModel): + title: str = "model" + secret: SecretStr = "secret" + + class ExampleSettings(BaseSettings): + title: str = "app" + model: ExampleModel = ExampleModel() + dictionary: dict = {"hello": "world"} + + return ExampleSettings() + + +@pytest.fixture +def faker(): + return Faker() diff --git a/tests/fixtures/inputs/gitlab/merge_request_webhook.json b/tests/fixtures/inputs/gitlab/merge_request_webhook.json new file mode 100755 index 0000000..a3974ea --- /dev/null +++ b/tests/fixtures/inputs/gitlab/merge_request_webhook.json @@ -0,0 +1,141 @@ +{ + "object_kind": "merge_request", + "event_type": "merge_request", + "user": + { + "id": 1287, + "name": "Ivan Zhirov", + "username": "ivan.zhirov", + "avatar_url": "https://git.env.local/uploads/-/system/user/avatar/1287/avatar.png", + "email": "example@mail.env.local" + }, + "project": + { + "id": 6617, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/secbot-test-group/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "namespace": "secbot-test-group", + "visibility_level": 0, + "path_with_namespace": "secbot-test-group/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/secbot-test-group/example-project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "http_url": "https://git.env.local/secbot-test-group/example-project.git" + }, + "object_attributes": + { + "assignee_id": null, + "author_id": 1287, + "created_at": "2023-02-02T09:44:56.081Z", + "description": "", + "head_pipeline_id": null, + "id": 83588, + "iid": 4, + "last_edited_at": null, + "last_edited_by_id": null, + "merge_commit_sha": null, + "merge_error": null, + "merge_params": + { + "force_remove_source_branch": "1" + }, + "merge_status": "unchecked", + "merge_user_id": null, + "merge_when_pipeline_succeeds": false, + "milestone_id": null, + "source_branch": "duplicate-2", + "source_project_id": 6617, + "state_id": 1, + "target_branch": "main", + "target_project_id": 6617, + "time_estimate": 0, + "title": "Duplicate 2", + "updated_at": "2023-02-07T13:51:22.027Z", + "updated_by_id": null, + "url": "https://git.env.local/secbot-test-group/example-project/-/merge_requests/4", + "source": + { + "id": 6617, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/secbot-test-group/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "namespace": "secbot-test-group", + "visibility_level": 0, + "path_with_namespace": "secbot-test-group/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/secbot-test-group/example-project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "http_url": "https://git.env.local/secbot-test-group/example-project.git" + }, + "target": + { + "id": 6617, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/secbot-test-group/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "namespace": "secbot-test-group", + "visibility_level": 0, + "path_with_namespace": "secbot-test-group/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/secbot-test-group/example-project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "http_url": "https://git.env.local/secbot-test-group/example-project.git" + }, + "last_commit": + { + "id": "ff01dde062e9d8b4636fc88d9d01017800422b05", + "message": "Hey ya\n", + "title": "Hey ya", + "timestamp": "2023-02-07T15:51:13+02:00", + "url": "https://git.env.local/secbot-test-group/example-project/-/commit/ff01dde062e9d8b4636fc88d9d01017800422b05", + "author": + { + "name": "Ivan Zhirov", + "email": "zhirovivan@gmail.com" + } + }, + "work_in_progress": false, + "total_time_spent": 0, + "time_change": 0, + "human_total_time_spent": null, + "human_time_change": null, + "human_time_estimate": null, + "assignee_ids": + [], + "reviewer_ids": + [], + "labels": + [], + "state": "opened", + "blocking_discussions_resolved": true, + "first_contribution": false, + "detailed_merge_status": "unchecked" + }, + "labels": + [], + "changes": + {}, + "repository": + { + "name": "Example Project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "description": "", + "homepage": "https://git.env.local/secbot-test-group/example-project" + } +} diff --git a/tests/fixtures/inputs/gitlab/push_webhook.json b/tests/fixtures/inputs/gitlab/push_webhook.json new file mode 100755 index 0000000..32ed9fd --- /dev/null +++ b/tests/fixtures/inputs/gitlab/push_webhook.json @@ -0,0 +1,84 @@ +{ + "object_kind": "push", + "event_name": "push", + "before": "5823620546f7624a111148d1bf60833f9e02c475", + "after": "23d5e3ab8e4dcda32a7acfb8343bfcfd12471e0a", + "ref": "refs/heads/main", + "checkout_sha": "23d5e3ab8e4dcda32a7acfb8343bfcfd12471e0a", + "message": null, + "user_id": 1287, + "user_name": "Ivan Zhirov", + "user_username": "ivan.zhirov", + "user_email": "", + "user_avatar": "https://git.env.local/uploads/-/system/user/avatar/1287/avatar.png", + "project_id": 6617, + "project": + { + "id": 6617, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/secbot-test-group/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "namespace": "secbot-test-group", + "visibility_level": 0, + "path_with_namespace": "secbot-test-group/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/secbot-test-group/example-project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "http_url": "https://git.env.local/secbot-test-group/example-project.git" + }, + "commits": + [ + { + "id": "23d5e3ab8e4dcda32a7acfb8343bfcfd12471e0a", + "message": "Added python file", + "title": "Added python file", + "timestamp": "2022-12-07T10:20:12+00:00", + "url": "https://git.env.local/secbot-test-group/example-project/-/commit/23d5e3ab8e4dcda32a7acfb8343bfcfd12471e0a", + "author": + { + "name": "Valerio Rico", + "email": "valerio.rico@mail.env.local" + }, + "added": ["app.py"], + "modified": [], + "removed": [] + }, + { + "id": "5823620546f7624a111148d1bf60833f9e02c475", + "message": "Update README.md", + "title": "Update README.md", + "timestamp": "2022-01-11T10:39:57+00:00", + "url": "https://git.env.local/secbot-test-group/example-project/-/commit/5823620546f7624a111148d1bf60833f9e02c475", + "author": + { + "name": "Valerio Rico", + "email": "valerio.rico@mail.env.local" + }, + "added": + [ + "README.md" + ], + "modified": + [], + "removed": + [] + } + ], + "total_commits_count": 2, + "push_options": {}, + "repository": + { + "name": "Example Project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "description": "", + "homepage": "https://git.env.local/secbot-test-group/example-project", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "visibility_level": 0 + } +} diff --git a/tests/fixtures/inputs/gitlab/tag_push_webhook.json b/tests/fixtures/inputs/gitlab/tag_push_webhook.json new file mode 100755 index 0000000..c1ca943 --- /dev/null +++ b/tests/fixtures/inputs/gitlab/tag_push_webhook.json @@ -0,0 +1,60 @@ +{ + "object_kind": "tag_push", + "event_name": "tag_push", + "before": "0000000000000000000000000000000000000000", + "after": "ff01dde062e9d8b4636fc88d9d01017800422b05", + "ref": "refs/tags/yo-5", + "checkout_sha": "ff01dde062e9d8b4636fc88d9d01017800422b05", + "message": "", + "user_id": 1287, + "user_name": "Ivan Zhirov", + "user_username": "ivan.zhirov", + "user_email": "", + "user_avatar": "https://git.env.local/uploads/-/system/user/avatar/1287/avatar.png", + "project_id": 6617, + "project": { + "id": 6617, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/secbot-test-group/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "namespace": "secbot-test-group", + "visibility_level": 0, + "path_with_namespace": "secbot-test-group/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/secbot-test-group/example-project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "http_url": "https://git.env.local/secbot-test-group/example-project.git" + }, + "commits": [ + { + "id": "ff01dde062e9d8b4636fc88d9d01017800422b05", + "message": "Hey ya\n", + "title": "Hey ya", + "timestamp": "2023-02-07T15:51:13+02:00", + "url": "https://git.env.local/secbot-test-group/example-project/-/commit/ff01dde062e9d8b4636fc88d9d01017800422b05", + "author": { + "name": "Ivan Zhirov", + "email": "zhirovivan@gmail.com" + }, + "added": [], + "modified": [], + "removed": [] + } + ], + "total_commits_count": 1, + "push_options": {}, + "repository": { + "name": "Example Project", + "url": "git@git.env.local:secbot-test-group/example-project.git", + "description": "", + "homepage": "https://git.env.local/secbot-test-group/example-project", + "git_http_url": "https://git.env.local/secbot-test-group/example-project.git", + "git_ssh_url": "git@git.env.local:secbot-test-group/example-project.git", + "visibility_level": 0 + } +} diff --git a/tests/fixtures/merge_request_hook__example_project.json b/tests/fixtures/merge_request_hook__example_project.json new file mode 100755 index 0000000..c5e1b22 --- /dev/null +++ b/tests/fixtures/merge_request_hook__example_project.json @@ -0,0 +1,127 @@ +{ + "object_kind": "merge_request", + "event_type": "merge_request", + "user": { + "id": 1337, + "name": "Firstname Lastname", + "username": "not.exists", + "avatar_url": "https://git.env.local/uploads/-/system/user/avatar/1337/avatar.png", + "email": "not.exists@mail.env.local" + }, + "project": { + "id": 1337, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "object_attributes": { + "assignee_id": null, + "author_id": 1337, + "created_at": "2011-11-11 11:33:37 UTC", + "description": "test", + "head_pipeline_id": null, + "id": 48872, + "iid": 1, + "last_edited_at": null, + "last_edited_by_id": null, + "merge_commit_sha": null, + "merge_error": null, + "merge_params": { + "force_remove_source_branch": "1" + }, + "merge_status": "unchecked", + "merge_user_id": null, + "merge_when_pipeline_succeeds": false, + "milestone_id": null, + "source_branch": "test", + "source_project_id": 1337, + "state_id": 1, + "target_branch": "main", + "target_project_id": 1337, + "time_estimate": 0, + "title": "Test", + "updated_at": "2011-11-11 11:33:37 UTC", + "updated_by_id": null, + "url": "https://git.env.local/security/example-project/-/merge_requests/1", + "source": { + "id": 1337, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "target": { + "id": 1337, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "last_commit": { + "id": "5823620546f7624a111148d1bf60833f9e02c475", + "message": "Update README.md", + "title": "Update README.md", + "timestamp": "2011-11-11T13:33:37+00:00", + "url": "https://git.env.local/security/example-project/-/commit/5823620546f7624a111148d1bf60833f9e02c475", + "author": { + "name": "Firstname Lastname", + "email": "not.exists@mail.env.local" + } + }, + "work_in_progress": false, + "total_time_spent": 0, + "time_change": 0, + "human_total_time_spent": null, + "human_time_change": null, + "human_time_estimate": null, + "assignee_ids": [ + + ], + "state": "opened" + }, + "labels": [ + + ], + "changes": { + }, + "repository": { + "name": "Example Project", + "url": "git@git.env.local:security/example-project.git", + "description": "", + "homepage": "https://git.env.local/security/example-project" + } +} diff --git a/tests/fixtures/merge_request_hook__public_site.json b/tests/fixtures/merge_request_hook__public_site.json new file mode 100755 index 0000000..fbe729d --- /dev/null +++ b/tests/fixtures/merge_request_hook__public_site.json @@ -0,0 +1,127 @@ +{ + "object_kind": "merge_request", + "event_type": "merge_request", + "user": { + "id": 662, + "name": "Valerio Rico", + "username": "valerio.rico", + "avatar_url": "https://git.env.local/uploads/-/system/user/avatar/662/avatar.png", + "email": "example@mail.env.local" + }, + "project": { + "id": 164, + "name": "Public Site", + "description": "", + "web_url": "https://git.env.local/public-site/backend", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:public-site/backend.git", + "git_http_url": "https://git.env.local/public-site/backend.git", + "namespace": "public-site", + "visibility_level": 0, + "path_with_namespace": "public-site/backend", + "default_branch": "master", + "ci_config_path": null, + "homepage": "https://git.env.local/public-site/backend", + "url": "git@git.env.local:public-site/backend.git", + "ssh_url": "git@git.env.local:public-site/backend.git", + "http_url": "https://git.env.local/public-site/backend.git" + }, + "object_attributes": { + "assignee_id": null, + "author_id": 662, + "created_at": "2022-01-11 11:49:13 UTC", + "description": "test", + "head_pipeline_id": null, + "id": 48872, + "iid": 1, + "last_edited_at": null, + "last_edited_by_id": null, + "merge_commit_sha": null, + "merge_error": null, + "merge_params": { + "force_remove_source_branch": "1" + }, + "merge_status": "cannot_be_merged", + "merge_user_id": null, + "merge_when_pipeline_succeeds": false, + "milestone_id": null, + "source_branch": "61.58.0", + "source_project_id": 164, + "state_id": 1, + "target_branch": "master", + "target_project_id": 164, + "time_estimate": 0, + "title": "Test", + "updated_at": "2022-01-11 11:49:13 UTC", + "updated_by_id": null, + "url": "https://git.env.local/public-site/backend/-/merge_requests/209", + "source": { + "id": 164, + "name": "Public Site", + "description": "", + "web_url": "https://git.env.local/public-site/backend", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:public-site/backend.git", + "git_http_url": "https://git.env.local/public-site/backend.git", + "namespace": "public-site", + "visibility_level": 0, + "path_with_namespace": "public-site/backend", + "default_branch": "master", + "ci_config_path": null, + "homepage": "https://git.env.local/public-site/backend", + "url": "git@git.env.local:public-site/backend.git", + "ssh_url": "git@git.env.local:public-site/backend.git", + "http_url": "https://git.env.local/public-site/backend.git" + }, + "target": { + "id": 164, + "name": "Public Site", + "description": "", + "web_url": "https://git.env.local/public-site/backend", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:public-site/backend.git", + "git_http_url": "https://git.env.local/public-site/backend.git", + "namespace": "public-site", + "visibility_level": 0, + "path_with_namespace": "public-site/backend", + "default_branch": "master", + "ci_config_path": null, + "homepage": "https://git.env.local/public-site/backend", + "url": "git@git.env.local:public-site/backend.git", + "ssh_url": "git@git.env.local:public-site/backend.git", + "http_url": "https://git.env.local/public-site/backend.git" + }, + "last_commit": { + "id": "6cfe17a9b11dfbe179ab593a4c7bf14deffb713f", + "message": "Update version", + "title": "Update version", + "timestamp": "2022-01-11T10:39:57+00:00", + "url": "https://git.env.local/public-site/backend/-/commit/6cfe17a9b11dfbe179ab593a4c7bf14deffb713f", + "author": { + "name": "Valerio Rico", + "email": "valerio.rico@mail.env.local" + } + }, + "work_in_progress": false, + "total_time_spent": 0, + "time_change": 0, + "human_total_time_spent": null, + "human_time_change": null, + "human_time_estimate": null, + "assignee_ids": [ + + ], + "state": "opened" + }, + "labels": [ + + ], + "changes": { + }, + "repository": { + "name": "Public Site", + "url": "git@git.env.local:public-site/backend.git", + "description": "", + "homepage": "https://git.env.local/public-site/backend" + } +} diff --git a/tests/fixtures/merge_request_hook__security_bot.json b/tests/fixtures/merge_request_hook__security_bot.json new file mode 100755 index 0000000..cf03f4a --- /dev/null +++ b/tests/fixtures/merge_request_hook__security_bot.json @@ -0,0 +1,127 @@ +{ + "object_kind": "merge_request", + "event_type": "merge_request", + "user": { + "id": 662, + "name": "Valerio Rico", + "username": "valerio.rico", + "avatar_url": "https://git.env.local/uploads/-/system/user/avatar/662/avatar.png", + "email": "example@mail.env.local" + }, + "project": { + "id": 4809, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "object_attributes": { + "assignee_id": null, + "author_id": 662, + "created_at": "2022-01-11 11:49:13 UTC", + "description": "test", + "head_pipeline_id": null, + "id": 48872, + "iid": 1, + "last_edited_at": null, + "last_edited_by_id": null, + "merge_commit_sha": null, + "merge_error": null, + "merge_params": { + "force_remove_source_branch": "1" + }, + "merge_status": "cannot_be_merged", + "merge_user_id": null, + "merge_when_pipeline_succeeds": false, + "milestone_id": null, + "source_branch": "test", + "source_project_id": 4809, + "state_id": 1, + "target_branch": "main", + "target_project_id": 4809, + "time_estimate": 0, + "title": "Test", + "updated_at": "2022-01-11 11:49:13 UTC", + "updated_by_id": null, + "url": "https://git.env.local/security/example-project/-/merge_requests/1", + "source": { + "id": 4809, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "target": { + "id": 4809, + "name": "Example Project", + "description": "", + "web_url": "https://git.env.local/security/example-project", + "avatar_url": null, + "git_ssh_url": "git@git.env.local:security/example-project.git", + "git_http_url": "https://git.env.local/security/example-project.git", + "namespace": "security", + "visibility_level": 0, + "path_with_namespace": "security/example-project", + "default_branch": "main", + "ci_config_path": null, + "homepage": "https://git.env.local/security/example-project", + "url": "git@git.env.local:security/example-project.git", + "ssh_url": "git@git.env.local:security/example-project.git", + "http_url": "https://git.env.local/security/example-project.git" + }, + "last_commit": { + "id": "5823620546f7624a111148d1bf60833f9e02c475", + "message": "Update README.md", + "title": "Update README.md", + "timestamp": "2022-01-11T10:39:57+00:00", + "url": "https://git.env.local/security/example-project/-/commit/5823620546f7624a111148d1bf60833f9e02c475", + "author": { + "name": "Valerio Rico", + "email": "valerio.rico@mail.env.local" + } + }, + "work_in_progress": false, + "total_time_spent": 0, + "time_change": 0, + "human_total_time_spent": null, + "human_time_change": null, + "human_time_estimate": null, + "assignee_ids": [ + + ], + "state": "opened" + }, + "labels": [ + + ], + "changes": { + }, + "repository": { + "name": "Example Project", + "url": "git@git.env.local:security/example-project.git", + "description": "", + "homepage": "https://git.env.local/security/example-project" + } +} diff --git a/tests/fixtures/worker_outputs/gitleaks.json b/tests/fixtures/worker_outputs/gitleaks.json new file mode 100755 index 0000000..360b4e2 --- /dev/null +++ b/tests/fixtures/worker_outputs/gitleaks.json @@ -0,0 +1,20 @@ +[ + { + "Description": "RSA private key", + "StartLine": 1, + "EndLine": 1, + "StartColumn": 8, + "EndColumn": 38, + "Match": "-----BEGIN RSA PRIVATE KEY-----", + "Secret": "-----BEGIN RSA PRIVATE KEY-----", + "File": "leaks.py", + "Commit": "9fd386858fea24cf4ed693a7ee6f553e3f7a4c49", + "Entropy": 0, + "Author": "Valerio Rico", + "Email": "valerio.rico@mail.env.local", + "Date": "2022-01-17T09:59:57Z", + "Message": "Add new file", + "Tags": [], + "RuleID": "RSA-PK" + } +] diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/integration/notifications/__init__.py b/tests/integration/notifications/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/integration/notifications/test_slack.py b/tests/integration/notifications/test_slack.py new file mode 100755 index 0000000..698322d --- /dev/null +++ b/tests/integration/notifications/test_slack.py @@ -0,0 +1,64 @@ +from unittest import mock + +import pytest + +from app.secbot.inputs.gitlab.handlers.slack import send_message + + +@pytest.mark.asyncio +@mock.patch( + "app.secbot.inputs.gitlab.handlers.slack.api.AsyncWebClient", new=mock.AsyncMock +) +async def test_sending_message_without_token(faker): + channel = faker.pystr() + payload = faker.pydict() + token = None + + with pytest.raises(AssertionError): + await send_message(channel=channel, payload=payload, token=token) + + +@pytest.mark.asyncio +@mock.patch( + "app.secbot.inputs.gitlab.handlers.slack.api.AsyncWebClient", new=mock.AsyncMock +) +async def test_sending_message_without_channel(faker): + channel = None + payload = faker.pydict() + token_value = faker.pystr() + token = mock.Mock(get_secret_value=mock.Mock(return_value=token_value)) + + with pytest.raises(AssertionError): + await send_message(channel=channel, payload=payload, token=token) + + +@pytest.mark.asyncio +@mock.patch( + "app.secbot.inputs.gitlab.handlers.slack.api.AsyncWebClient", new=mock.AsyncMock +) +async def test_sending_message_without_payload(faker): + channel = faker.pystr() + payload = None + token_value = faker.pystr() + token = mock.Mock(get_secret_value=mock.Mock(return_value=token_value)) + + with pytest.raises(AssertionError): + await send_message(channel=channel, payload=payload, token=token) + + +@pytest.mark.asyncio +@mock.patch( + "app.secbot.inputs.gitlab.handlers.slack.api.AsyncWebClient.chat_postMessage" +) +async def test_sending_message(post_message_mock, faker): + channel = faker.pystr() + payload = faker.pydict() + token_value = faker.pystr() + token = mock.Mock(get_secret_value=mock.Mock(return_value=token_value)) + + await send_message(channel=channel, payload=payload, token=token) + + post_message_mock.assert_called_once_with( + channel=channel, + blocks=payload, + ) diff --git a/tests/integration/test_outputs.py b/tests/integration/test_outputs.py new file mode 100755 index 0000000..6dba318 --- /dev/null +++ b/tests/integration/test_outputs.py @@ -0,0 +1,53 @@ +from unittest import mock + +import pytest + +from app.secbot.inputs.gitlab.handlers.defectdojo.services import ( + OutputResultObject, + send_result, +) +from tests.units.factories import create_merge_request_webhook__security_bot + + +@pytest.mark.asyncio +@pytest.mark.parametrize("fixture_file_path", ["gitleaks.json"]) +@mock.patch("app.secbot.inputs.gitlab.handlers.defectdojo.services.dd_upload") +@mock.patch("app.secbot.inputs.gitlab.handlers.defectdojo.services.dd_get_test") +@mock.patch("app.secbot.inputs.gitlab.handlers.defectdojo.services.dd_prepare") +@mock.patch( + "app.secbot.inputs.gitlab.handlers.defectdojo.services.dd_findings_by_test" +) +@mock.patch("app.secbot.inputs.gitlab.handlers.defectdojo.services.asyncio.sleep") +async def test_defectdojo_output( + # TODO(ivan.zhirov): mock tests with time.sleep + sleep, + dd_findings_by_test, + dd_prepare, + dd_get_test, + dd_upload, + dir_tests, + fixture_file_path, +): + data = create_merge_request_webhook__security_bot() + with open( + dir_tests / "fixtures/worker_outputs" / fixture_file_path + ) as output_data: + result = OutputResultObject( + data=data, + worker=fixture_file_path.split(".")[0], + result=output_data.read(), + ) + + dd_get_test.return_value = {"percent_complete": 100} + + # TODO(ivan.zhirov): mock the response from the server + dd_findings_by_test.return_value = {"count": 1, "results": []} + + credentials = mock.Mock() + + assert await send_result(credentials=credentials, output_result=result) + + dd_prepare.assert_called_once() + dd_upload.assert_called_once() + dd_get_test.assert_called() + dd_findings_by_test.assert_called_once() diff --git a/tests/pytest.ini b/tests/pytest.ini new file mode 100755 index 0000000..ac78af1 --- /dev/null +++ b/tests/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +log_cli=true +log_cli_level=DEBUG \ No newline at end of file diff --git a/tests/test_logger.py b/tests/test_logger.py new file mode 100755 index 0000000..a354222 --- /dev/null +++ b/tests/test_logger.py @@ -0,0 +1,12 @@ +from app import format_extra + + +def test_format_with_extra(faker): + message = faker.pystr() + extra = {"hello": "app"} + assert format_extra(message, extra) == f"{message} EXTRA: hello=app" + + +def test_format_without_extra(faker): + message = faker.pystr() + assert format_extra(message, None) == f"{message}" diff --git a/tests/test_sentry.py b/tests/test_sentry.py new file mode 100755 index 0000000..cf7021f --- /dev/null +++ b/tests/test_sentry.py @@ -0,0 +1,25 @@ +from app.main import sanitize_event_values +from app.settings import flatten_settings_values + + +def test_sanitize_event_values(example_settings): + example_event = { + "exceptions": { + "values": [ + "Hello, world", + "Hello, app", + ], + "val": "Today in app we rule the world", + } + } + values = flatten_settings_values(example_settings) + assert sanitize_event_values( + value=example_event, + # Sensitive words: world, app, model, secret + sensitive_values=values, + ) == { + "exceptions": { + "values": ["Hello, [Redacted]", "Hello, [Redacted]"], + "val": "Today in [Redacted] we rule the [Redacted]", + } + } diff --git a/tests/test_settings.py b/tests/test_settings.py new file mode 100755 index 0000000..a1d0d94 --- /dev/null +++ b/tests/test_settings.py @@ -0,0 +1,6 @@ +from app.settings import flatten_settings_values + + +def test_flatten_settings_values(example_settings): + values = flatten_settings_values(example_settings) + assert values == {"app", "model", "secret", "world"} diff --git a/tests/units/__init__.py b/tests/units/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/common.py b/tests/units/common.py new file mode 100755 index 0000000..7bf4d35 --- /dev/null +++ b/tests/units/common.py @@ -0,0 +1,5 @@ +import pathlib + + +def get_test_root_directory(): + return pathlib.Path(__file__).parent.parent.resolve() diff --git a/tests/units/config/__init__.py b/tests/units/config/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/config/test_config_v1_parser.py b/tests/units/config/test_config_v1_parser.py new file mode 100755 index 0000000..3701b9f --- /dev/null +++ b/tests/units/config/test_config_v1_parser.py @@ -0,0 +1,142 @@ +from unittest import mock + +import pytest + +from app.secbot.config import SecbotConfigComponent, WorkflowJob, config_parser +from app.secbot.exceptions import SecbotConfigError, SecbotConfigMissingEnv + + +def test_config_v1_parser_empty_components(): + with pytest.raises(SecbotConfigError): + config_parser({"version": "1.0", "components": {}, "jobs": []}) + + +def test_config_v1_parser_empty_jobs(): + with pytest.raises(SecbotConfigError): + config_parser( + { + "version": "1.0", + "components": { + "component": { + "handler_name": "handler", + "config": {"key": "value"}, + }, + }, + "jobs": [], + } + ) + + +@mock.patch("app.secbot.config.os.getenv") +def test_config_v1_parser_missing_env(getenv_mock): + getenv_mock.side_effect = AttributeError + with pytest.raises(SecbotConfigMissingEnv): + config_parser( + { + "version": "1.0", + "components": { + "component": { + "handler_name": "handler", + "env": { + "key1": "value1", + }, + }, + }, + "jobs": [ + { + "name": "job1", + "rules": {"input": {"some": "rule"}}, + "scans": ["component"], + "outputs": ["component"], + "notifications": [], + } + ], + } + ) + + +@mock.patch("app.secbot.config.os.getenv") +def test_config_v1_parser(getenv, faker): + example_env_value = faker.pystr() + getenv.return_value = example_env_value + + handler_1_name = faker.pystr() + handler_2_name = faker.pystr() + config_2 = faker.pydict() + input_name = faker.pystr() + + obj = { + "version": "1.0", + "components": { + "component1": { + "handler_name": handler_1_name, + "env": {"key": "value"}, + }, + "component2": { + "handler_name": handler_2_name, + "config": config_2, + }, + }, + "jobs": [ + { + "name": "job1", + "rules": {input_name: {"some": "rule"}}, + "scans": ["component1"], + "outputs": ["component2"], + "notifications": [], + }, + { + "name": "job2", + "rules": {input_name: {"some": "rule"}}, + "scans": ["component2"], + "outputs": ["component1"], + "notifications": [], + }, + ], + } + result = config_parser(obj) + + # Check that getenv was called + getenv.assert_called_once_with("value") + + assert input_name in result + assert len(result[input_name]) == 2 + + assert all(isinstance(item, WorkflowJob) for item in result[input_name]) + + assert result[input_name][0].name == "job1" + assert result[input_name][1].name == "job2" + + assert result[input_name][0].scans == [ + SecbotConfigComponent( + handler_name=handler_1_name, + name="component1", + config=None, + env={"key": example_env_value}, + ) + ] + assert result[input_name][0].outputs == [ + SecbotConfigComponent( + handler_name=handler_2_name, + name="component2", + config=config_2, + env=None, + ) + ] + + assert result[input_name][1].scans == [ + SecbotConfigComponent( + handler_name=handler_2_name, + name="component2", + config=config_2, + env=None, + ) + ] + assert result[input_name][1].outputs == [ + SecbotConfigComponent( + handler_name=handler_1_name, + name="component1", + config=None, + env={"key": example_env_value}, + ) + ] diff --git a/tests/units/config/test_secbot_config_version.py b/tests/units/config/test_secbot_config_version.py new file mode 100755 index 0000000..5b0eb3e --- /dev/null +++ b/tests/units/config/test_secbot_config_version.py @@ -0,0 +1,27 @@ +from unittest import mock + +import pytest + +from app.secbot.config import SecbotConfig +from app.secbot.exceptions import SecbotConfigError + + +def test_missing_version_key(): + config_obj = {"components": {}, "jobs": []} + with pytest.raises(SecbotConfigError): + SecbotConfig(config_obj) + + +def test_unsupported_version(): + config_obj = {"version": "invalid_version", "components": {}, "jobs": []} + with pytest.raises(SecbotConfigError): + SecbotConfig(config_obj) + + +def test_valid_config(): + version = "1.0" + mock_parser = mock.MagicMock() + with mock.patch.dict(SecbotConfig.VERSIONS_PARSER, {version: mock_parser}): + config_obj = {"version": version, "components": {}, "jobs": []} + SecbotConfig(config_obj) + mock_parser.assert_called_once_with(config_obj) diff --git a/tests/units/factories.py b/tests/units/factories.py new file mode 100755 index 0000000..b67c41b --- /dev/null +++ b/tests/units/factories.py @@ -0,0 +1,69 @@ +import json + +from app.secbot.inputs.gitlab.schemas import MergeRequestWebhookModel +from app.secbot.inputs.gitlab.schemas.base import Project +from tests.units.common import get_test_root_directory + + +def create_project__example(): + project = Project( + id=4809, + name="Example Project", + web_url="https://git.env.local/security/example-project/", + git_ssh_url="git@git.env.local:security/example-project.git", + git_http_url="https://git.env.local/security/example-project.git", + namespace="security", + path_with_namespace="security/example-project", + ) + return project + + +def create_project__security(): + project = Project( + id=4801, + name="Security Bot", + web_url="https://git.env.local/security/security-bot/", + git_ssh_url="git@git.env.local:security/security-bot.git", + git_http_url="https://git.env.local/security/security-bot.git", + namespace="security", + path_with_namespace="security/security-bot", + ) + return project + + +def create_project__public_site(): + project = Project( + id=164, + name="Public Site", + web_url="https://git.env.local/public-site/backend/", + git_ssh_url="git@git.env.local:public-site/backend.git", + git_http_url="https://git.env.local/public-site/backend.git", + namespace="public-site", + path_with_namespace="public-site/backend", + ) + return project + + +def create_merge_request_webhook__example_project(): + with open( + get_test_root_directory() + / "fixtures" + / "merge_request_hook__example_project.json" + ) as json_data: + return MergeRequestWebhookModel(**json.load(json_data), raw={}) + + +def create_merge_request_webhook__security_bot(): + with open( + get_test_root_directory() + / "fixtures" + / "merge_request_hook__security_bot.json" + ) as json_data: + return MergeRequestWebhookModel(**json.load(json_data), raw={}) + + +def create_merge_request_webhook__public_site(): + with open( + get_test_root_directory() / "fixtures" / "merge_request_hook__public_site.json" + ) as json_data: + return MergeRequestWebhookModel(**json.load(json_data), raw={}) diff --git a/tests/units/inputs/__init__.py b/tests/units/inputs/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/inputs/config/__init__.py b/tests/units/inputs/config/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/inputs/config/test_config_utils.py b/tests/units/inputs/config/test_config_utils.py new file mode 100755 index 0000000..6e4ed8a --- /dev/null +++ b/tests/units/inputs/config/test_config_utils.py @@ -0,0 +1,7 @@ +from app.secbot.config import get_jsonpath_value + + +def test_config_get_jsonpath_value(): + meaning_of_the_universe = 42 + data = {"base": {"deep": {"deeper": {"here": meaning_of_the_universe}}}} + assert get_jsonpath_value(data, "base.deep.deeper.here") == meaning_of_the_universe diff --git a/tests/units/inputs/config/test_parse_jobs.py b/tests/units/inputs/config/test_parse_jobs.py new file mode 100755 index 0000000..5969a32 --- /dev/null +++ b/tests/units/inputs/config/test_parse_jobs.py @@ -0,0 +1,115 @@ +import pytest +import yaml + +from app.secbot.config import SecbotConfig +from app.secbot.exceptions import SecbotConfigError +from app.secbot.inputs.gitlab.schemas import GitlabEvent + + +def test_parse_yaml_with_repo_regex_exclude(get_event_data): + yaml_string = """ + version: "1.0" + components: + gitleaks: + handler_name: gitleaks + defectdojo: + handler_name: defectdojo + slack: + handler_name: slack + jobs: + - name: Exclude gitlab + rules: + gitlab: + event_type: "merge_request" + project.path_with_namespace: "!secbot-test-group/.*" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + + - name: Another merge request + rules: + gitlab: + event_type: "merge_request" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + + - name: Some job merge request + rules: + gitlab: + event_type: "push_tags" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + """ # noqa: W291,E261 + + yaml_config = SecbotConfig(yaml.safe_load(yaml_string)) + data = get_event_data( + GitlabEvent.MERGE_REQUEST, + {"project": {"path_with_namespace": "secbot-test-group/example-project"}}, + ) + assert yaml_config.matching_workflow_job("gitlab", data=data) + + +def test_parse_yaml_with_repo_regex(get_event_data): + yaml_string = """ + version: "1.0" + components: + gitleaks: + handler_name: gitleaks + defectdojo: + handler_name: defectdojo + slack: + handler_name: slack + jobs: + - name: Exclude gitlab + rules: + gitlab: + event_type: "merge_request" + project.path_with_namespace: "secbot-test-group/.*" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + + - name: Another merge request + rules: + gitlab: + event_type: "merge_request" + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + + - name: Some other job + rules: + gitlab: + event_type: "push_tags" + example: + scans: + - gitleaks + outputs: + - defectdojo + notifications: + - slack + """ # noqa: W291,E261 + secbot_config = SecbotConfig(yaml.safe_load(yaml_string)) + data = get_event_data( + GitlabEvent.MERGE_REQUEST, + {"project": {"path_with_namespace": "secbot-test-group/example-project"}}, + ) + with pytest.raises(SecbotConfigError): + secbot_config.matching_workflow_job("gitlab", data=data) diff --git a/tests/units/inputs/conftest.py b/tests/units/inputs/conftest.py new file mode 100755 index 0000000..4cb1af5 --- /dev/null +++ b/tests/units/inputs/conftest.py @@ -0,0 +1,46 @@ +import json +import pathlib +from typing import Dict, Optional + +import pytest +from pydantic.utils import deep_update + +from app.secbot.inputs.gitlab.schemas import GitlabEvent + +GITLAB_EVENT_RESPONSE_MAP: Dict[GitlabEvent, str] = { + GitlabEvent.MERGE_REQUEST: "fixtures/inputs/gitlab/merge_request_webhook.json", + GitlabEvent.PUSH: "fixtures/inputs/gitlab/push_webhook.json", + GitlabEvent.TAG_PUSH: "fixtures/inputs/gitlab/tag_push_webhook.json", +} + + +@pytest.fixture +def get_event_data(dir_tests): + def handler(event: GitlabEvent, overrides: Optional[dict] = None) -> dict: + file_path = GITLAB_EVENT_RESPONSE_MAP[event] + with open(pathlib.Path(dir_tests, file_path), "r") as file: + data = json.loads(file.read()) + data = deep_update(data, overrides or {}) + data["raw"] = data + return data + + return handler + + +@pytest.fixture +def generate_commit_data(faker): + def handler(overrides: Optional[dict] = None) -> dict: + data = { + "id": faker.md5(), + "message": faker.pystr(), + "title": faker.pystr(), + "timestamp": faker.iso8601(), + "url": faker.uri(), + "author": {"name": faker.name(), "email": faker.ascii_email()}, + "added": [], + "modified": [], + "removed": [], + } + return deep_update(data, overrides or {}) + + return handler diff --git a/tests/units/inputs/gitlab/__init__.py b/tests/units/inputs/gitlab/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/inputs/gitlab/handlers/__init__.py b/tests/units/inputs/gitlab/handlers/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/inputs/gitlab/handlers/slack/__init__.py b/tests/units/inputs/gitlab/handlers/slack/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/inputs/gitlab/handlers/slack/test_slack_message_generation.py b/tests/units/inputs/gitlab/handlers/slack/test_slack_message_generation.py new file mode 100755 index 0000000..4c0ad2e --- /dev/null +++ b/tests/units/inputs/gitlab/handlers/slack/test_slack_message_generation.py @@ -0,0 +1,110 @@ +from typing import Optional + +import pytest +from polyfactory.factories.pydantic_factory import ModelFactory + +from app.secbot.inputs.gitlab.handlers.slack import generate_message_blocks +from app.secbot.inputs.gitlab.schemas import ( + GitlabOutputResult, + GitlabScanResult, + GitlabScanResultFile, +) +from app.secbot.inputs.gitlab.schemas.output_responses import ( + OutputFinding, + OutputResponse, +) + + +class GitlabScanResultFileFactory(ModelFactory[GitlabScanResultFile]): + __model__ = GitlabScanResultFile + + content = {} + + +class GitlabScanResultFactory(ModelFactory[GitlabScanResult]): + __model__ = GitlabScanResult + + file = GitlabScanResultFileFactory.build() + + +class OutputResultFactory(ModelFactory[GitlabOutputResult]): + __model__ = GitlabOutputResult + + scan_result = GitlabScanResultFactory.build() + + +class FindingFactory(ModelFactory[OutputFinding]): + __model__ = OutputFinding + + +@pytest.fixture +def output_result_factory(faker): + def factory( + findings_size: int = 10, + project_name: Optional[str] = None, + project_url: Optional[str] = None, + ): + if not project_name: + project_name = faker.pystr() + + if not project_url: + project_url = faker.uri() + + return OutputResultFactory.build( + response=OutputResponse( + project_name=project_name, + project_url=project_url, + findings=FindingFactory.batch(size=findings_size), + ), + ) + + return factory + + +def generate_slack_message_block(msg: str) -> dict: + return {"type": "section", "text": {"type": "mrkdwn", "text": msg}} + + +def test_slack_message_generation_with_correct_worker_name( + output_result_factory, faker +): + findings_size = faker.pyint(max_value=25) + project_name = faker.pystr() + project_url = faker.uri() + + output_result = output_result_factory( + project_name=project_name, + project_url=project_url, + findings_size=findings_size, + ) + message_blocks = generate_message_blocks(output_result, render_limit=10) + assert message_blocks is not None + + worker_name = output_result.scan_result.component_name + + # Check that the title has correct worker name and project name + assert message_blocks[0] == generate_slack_message_block( + f"Worker *{worker_name}* found *{findings_size}* new findings in *<{project_url}|{project_name}>*:" + ) + + +def test_slack_message_generation_without_findings(output_result_factory): + output_result = output_result_factory(findings_size=0) + assert generate_message_blocks(output_result, render_limit=10) is None + + +def test_slack_message_generation_with_extra_limit(output_result_factory): + render_limit = 10 + findings_size = 15 + output_result = output_result_factory(findings_size=findings_size) + + message_blocks = generate_message_blocks(output_result, render_limit=render_limit) + assert message_blocks is not None + + # Plus header and footer + assert len(message_blocks) == render_limit + 2 + + # Assert footer + assert message_blocks[-1] == generate_slack_message_block( + f":no_bell: *{findings_size - render_limit}* were *stripped* from notification :no_bell:" + ) diff --git a/tests/units/inputs/gitlab/test_defectdojo_validation.py b/tests/units/inputs/gitlab/test_defectdojo_validation.py new file mode 100755 index 0000000..cc520e0 --- /dev/null +++ b/tests/units/inputs/gitlab/test_defectdojo_validation.py @@ -0,0 +1,119 @@ +import pytest + +from app.secbot.inputs.gitlab.handlers.defectdojo.validator import ( + DefectDojoFindingDuplicate, + DefectDojoFindings, + is_gitleaks_valid, +) +from app.secbot.schemas import Severity + + +def test_which_finding_active_without_duplicate(faker): + is_valid = faker.pybool() + finding = DefectDojoFindings( + active=is_valid, + scan_name="gitleaks", + severity=Severity.HIGH, + duplicate=None, + ) + assert finding.is_active is is_valid + + +def test_which_finding_active_with_duplicate(): + duplicate = DefectDojoFindingDuplicate( + active=True, + severity=Severity.HIGH, + ) + finding = DefectDojoFindings( + active=False, + scan_name="gitleaks", + severity=Severity.HIGH, + duplicate=duplicate, + ) + assert finding.is_active is True + + +def test_is_gitleaks_with_wrong_check_service_type(): + findings = [ + DefectDojoFindings( + active=True, + scan_name="some-other-service", + severity=Severity.HIGH, + duplicate=None, + ), + DefectDojoFindings( + active=True, + scan_name="gitleaks", + severity=Severity.HIGH, + duplicate=None, + ), + ] + with pytest.raises(AssertionError): + is_gitleaks_valid(findings) + + +@pytest.mark.parametrize( + "findings, expected", + [ + ([], True), + # No matter severities. If there is an active finding, the function returns False + ( + [ + DefectDojoFindings( + active=True, + scan_name="gitleaks", + severity=Severity.INFO, + duplicate=None, + ), + DefectDojoFindings( + active=True, + scan_name="gitleaks", + severity=Severity.LOW, + duplicate=None, + ), + ], + False, + ), + # All findings are inactive + ( + [ + DefectDojoFindings( + active=False, + scan_name="gitleaks", + severity=Severity.CRITICAL, + duplicate=None, + ), + DefectDojoFindings( + active=False, + scan_name="gitleaks", + severity=Severity.HIGH, + duplicate=None, + ), + ], + True, + ), + # Active in duplicate + ( + [ + DefectDojoFindings( + active=False, + scan_name="gitleaks", + severity=Severity.CRITICAL, + duplicate=DefectDojoFindingDuplicate( + active=True, + severity=Severity.CRITICAL, + ), + ), + DefectDojoFindings( + active=False, + scan_name="gitleaks", + severity=Severity.HIGH, + duplicate=None, + ), + ], + False, + ), + ], +) +def test_is_gitleaks_valid(findings, expected): + assert is_gitleaks_valid(findings) == expected diff --git a/tests/units/inputs/gitlab/test_gitlab_dependencies.py b/tests/units/inputs/gitlab/test_gitlab_dependencies.py new file mode 100755 index 0000000..fe319e6 --- /dev/null +++ b/tests/units/inputs/gitlab/test_gitlab_dependencies.py @@ -0,0 +1,90 @@ +from unittest import mock + +import pytest +from fastapi import HTTPException + +from app.secbot.inputs.gitlab.dependencies import ( + get_gitlab_webhook_token_header, + gitlab_event, +) +from app.secbot.inputs.gitlab.schemas import GitlabEvent + + +@mock.patch("app.secbot.inputs.gitlab.dependencies.settings") +def test_gitlab_webhook_token_header(settings_mock, faker): + token = faker.pystr() + + get_secret_value_mock = mock.Mock(get_secret_value=mock.Mock(return_value=token)) + settings_mock.gitlab_configs = [ + mock.Mock(webhook_secret_token=get_secret_value_mock), + ] + + assert get_gitlab_webhook_token_header(x_gitlab_token=token) == token + + +@mock.patch("app.secbot.inputs.gitlab.dependencies.settings") +def test_gitlab_webhook_token_header_invalid(settings_mock): + get_secret_value_mock = mock.Mock(get_secret_value=mock.Mock(return_value="valid")) + settings_mock.gitlab_configs = [ + mock.Mock(webhook_secret_token=get_secret_value_mock), + ] + + with pytest.raises(HTTPException): + get_gitlab_webhook_token_header(x_gitlab_token="invalid") + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "event_name, payload, expected_event", + [ + ( + "System Hook", + {"event_type": "merge_request"}, + GitlabEvent.MERGE_REQUEST, + ), + ( + "System Hook", + {"event_name": "push"}, + GitlabEvent.PUSH, + ), + ( + "System Hook", + {"event_name": "tag_push"}, + GitlabEvent.TAG_PUSH, + ), + ( + "Merge Request Hook", + {"event_type": "merge_request"}, + GitlabEvent.MERGE_REQUEST, + ), + ( + "Push Hook", + {"event_name": "push"}, + GitlabEvent.PUSH, + ), + ( + "Tag Push Hook", + {"event_name": "tag_push"}, + GitlabEvent.TAG_PUSH, + ), + ], +) +async def test_gitlab_event_event_detection(event_name, payload, expected_event): + request_mock = mock.Mock(json=mock.AsyncMock(return_value=payload)) + event = await gitlab_event(request_mock, x_gitlab_event=event_name) + assert event == expected_event + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "event_name", + [ + "System Hook", + "Random event name", + ], +) +async def test_gitlab_not_supported_event(event_name, faker): + random_event_payload = faker.pydict() + request_mock = mock.Mock(json=mock.AsyncMock(return_value=random_event_payload)) + event = await gitlab_event(request_mock, x_gitlab_event=event_name) + assert event is None diff --git a/tests/units/inputs/gitlab/test_gitlab_project_languages.py b/tests/units/inputs/gitlab/test_gitlab_project_languages.py new file mode 100755 index 0000000..c8348bf --- /dev/null +++ b/tests/units/inputs/gitlab/test_gitlab_project_languages.py @@ -0,0 +1,76 @@ +from unittest import mock + +import pytest + +from app.secbot.inputs.gitlab.schemas.base import Project +from app.secbot.inputs.gitlab.services import get_gitlab_project_languages + + +@pytest.fixture +def project_factory(): + def _factory( + project_id: int = 42, + web_url: str = "https://git.env.local/secbot-test-group/example-project", + ): + return Project( + id=project_id, + name="test", + web_url=web_url, + git_ssh_url="ssh://git.env.local/secbot-test-group/example-project", + git_http_url="https://git.env.local/secbot-test-group/example-project", + namespace="secbot-test-group", + path_with_namespace="secbot-test-group/example-project", + ) + + return _factory + + +@mock.patch("app.secbot.inputs.gitlab.services.requests.get") +@mock.patch("app.secbot.inputs.gitlab.services.get_config_from_host") +def test_gitlab_project_languages_api_url( + config_mock, requests_mock, faker, project_factory +): + token = faker.pystr() + project_id = faker.pyint() + web_url = "https://git.env.local/secbot-test-group/example-project" + project = project_factory(web_url=web_url, project_id=project_id) + + config_mock.return_value.auth_token.get_secret_value.return_value = token + + get_gitlab_project_languages(project) + + requests_mock.assert_called_once_with( + url=f"https://git.env.local/api/v4/projects/{project_id}/languages", + headers={"PRIVATE-TOKEN": token}, + ) + + +@mock.patch( + "app.secbot.inputs.gitlab.services.requests.get", + return_value=mock.Mock( + status_code=400, + json=mock.MagicMock(return_value={"message": "error message"}), + ), +) +@mock.patch("app.secbot.inputs.gitlab.services.get_config_from_host") +def test_gitlab_project_languages_non_success(_config_mock, _mock, project_factory): + project = project_factory() + assert get_gitlab_project_languages(project) is None + + +@mock.patch( + "app.secbot.inputs.gitlab.services.requests.get", + return_value=mock.Mock( + status_code=200, + json=mock.MagicMock(return_value={"Python": "90.00", "Shell": "10.00"}), + ), +) +@mock.patch("app.secbot.inputs.gitlab.services.get_config_from_host") +def test_gitlab_project_languages_success_response( + _config_mock, _mock, project_factory +): + project = project_factory() + assert get_gitlab_project_languages(project) == { + "Python": "90.00", + "Shell": "10.00", + } diff --git a/tests/units/inputs/gitlab/test_gitlab_routes.py b/tests/units/inputs/gitlab/test_gitlab_routes.py new file mode 100755 index 0000000..289fa63 --- /dev/null +++ b/tests/units/inputs/gitlab/test_gitlab_routes.py @@ -0,0 +1,23 @@ +import pytest +from starlette.testclient import TestClient + +from app.main import app +from app.secbot.inputs.gitlab.dependencies import get_gitlab_webhook_token_header + +client = TestClient(app) +app.dependency_overrides[get_gitlab_webhook_token_header] = lambda: "token" + + +@pytest.mark.asyncio +async def test_gitlab_route_not_failed_with_invalid_data_event(faker): + invalid_merge_request_data = { + "event_type": "merge_request", + **faker.pydict(allowed_types=["str", "int", "float", "bool"]), + } + response = client.post( + "/v1/gitlab/webhook", + headers={"X-Gitlab-Event": "Merge Request Hook"}, + json=invalid_merge_request_data, + ) + assert response.status_code == 200 + assert response.json() == {"status": "ok"} diff --git a/tests/units/inputs/gitlab/test_gitlab_utils.py b/tests/units/inputs/gitlab/test_gitlab_utils.py new file mode 100755 index 0000000..0a4267a --- /dev/null +++ b/tests/units/inputs/gitlab/test_gitlab_utils.py @@ -0,0 +1,46 @@ +from unittest import mock + +import pytest + +from app.secbot.inputs.gitlab import generate_gitlab_security_id +from app.secbot.inputs.gitlab.utils import get_project_name + + +@pytest.mark.parametrize( + "project_path, expected_project_name", + [ + ( + "git.env.local:sample-group/sample-project.git", + "git.env.local:sample-group/sample-project", + ), + ( + "git@git.env.local:sample-group/sample-project", + "git.env.local:sample-group/sample-project", + ), + ], +) +def test_get_project_name_with_git_at_the_end(project_path, expected_project_name): + assert get_project_name(project_path) == expected_project_name + + +def test_get_project_name_with_plain_string(faker): + simple_string = faker.pystr() + project_name = get_project_name(simple_string) + assert simple_string == project_name + + +# noinspection SpellCheckingInspection +def test_generate_gitlab_security_id(): + prefix = "prefix" + commit_hash = "commit_hash" + project_path = "git.env.local:sample-group/sample-project.git" + + data = mock.Mock( + commit=mock.Mock(id=commit_hash), + project=mock.Mock(git_ssh_url=project_path), + ) + security_id = generate_gitlab_security_id(prefix=prefix, data=data) + assert ( + security_id + == "prefix_8666e7b2f4a9023e9049d3e1dcc6012c8ede0351562876d482fa89d07a66f6f0" + ) diff --git a/tests/units/inputs/gitlab/test_merge_request_webhook_data.py b/tests/units/inputs/gitlab/test_merge_request_webhook_data.py new file mode 100755 index 0000000..3eeb0d0 --- /dev/null +++ b/tests/units/inputs/gitlab/test_merge_request_webhook_data.py @@ -0,0 +1,30 @@ +from app.secbot.inputs.gitlab.schemas import GitlabEvent, MergeRequestWebhookModel + + +def test_merge_request_webhook_data_commit(get_event_data, faker): + commit_hash = faker.md5() + data = get_event_data( + GitlabEvent.MERGE_REQUEST, + {"object_attributes": {"last_commit": {"id": commit_hash}}}, + ) + instance = MergeRequestWebhookModel(**data) + assert instance.commit.id == commit_hash + + +def test_merge_request_webhook_data_target_branch(get_event_data, faker): + target_branch = faker.pystr() + data = get_event_data( + GitlabEvent.MERGE_REQUEST, + {"object_attributes": {"target_branch": target_branch}}, + ) + instance = MergeRequestWebhookModel(**data) + assert instance.target_branch == target_branch + + +def test_merge_request_webhook_data_path(get_event_data, faker): + path = faker.uri() + data = get_event_data( + GitlabEvent.MERGE_REQUEST, {"object_attributes": {"url": path}} + ) + instance = MergeRequestWebhookModel(**data) + assert instance.path == path diff --git a/tests/units/inputs/gitlab/test_push_webhook_data.py b/tests/units/inputs/gitlab/test_push_webhook_data.py new file mode 100755 index 0000000..e9cd2f2 --- /dev/null +++ b/tests/units/inputs/gitlab/test_push_webhook_data.py @@ -0,0 +1,53 @@ +from app.secbot.inputs.gitlab.schemas import GitlabEvent, PushWebhookModel + + +def test_push_webhook_data_commit(get_event_data, generate_commit_data, faker): + commit_hash = faker.md5() + data = get_event_data( + GitlabEvent.PUSH, + { + "after": commit_hash, + "commits": [ + generate_commit_data(), + generate_commit_data( + { + "id": commit_hash, + } + ), + ], + }, + ) + instance = PushWebhookModel(**data) + assert instance.commit.id == commit_hash + + +def test_push_webhook_data_target_branch(get_event_data, faker): + target_branch = faker.pystr() + data = get_event_data( + GitlabEvent.PUSH, + {"ref": f"ref/heads/{target_branch}"}, + ) + instance = PushWebhookModel(**data) + assert instance.target_branch == target_branch + + +def test_push_webhook_data_path(get_event_data, generate_commit_data, faker): + commit_hash = faker.md5() + path = faker.uri() + data = get_event_data( + GitlabEvent.PUSH, + { + "after": commit_hash, + "commits": [ + generate_commit_data(), + generate_commit_data( + { + "id": commit_hash, + "url": path, + } + ), + ], + }, + ) + instance = PushWebhookModel(**data) + assert instance.path == path diff --git a/tests/units/inputs/gitlab/test_tag_push_webhook_data.py b/tests/units/inputs/gitlab/test_tag_push_webhook_data.py new file mode 100755 index 0000000..286390e --- /dev/null +++ b/tests/units/inputs/gitlab/test_tag_push_webhook_data.py @@ -0,0 +1,53 @@ +from app.secbot.inputs.gitlab.schemas import GitlabEvent, TagWebhookModel + + +def test_tag_push_webhook_data_commit(get_event_data, generate_commit_data, faker): + commit_hash = faker.md5() + data = get_event_data( + GitlabEvent.TAG_PUSH, + { + "checkout_sha": commit_hash, + "commits": [ + generate_commit_data(), + generate_commit_data( + { + "id": commit_hash, + } + ), + ], + }, + ) + instance = TagWebhookModel(**data) + assert instance.commit.id == commit_hash + + +def test_tag_push_webhook_data_target_branch(get_event_data, faker): + target_branch = faker.pystr() + data = get_event_data( + GitlabEvent.TAG_PUSH, + {"ref": f"ref/tags/{target_branch}"}, + ) + instance = TagWebhookModel(**data) + assert instance.target_branch == target_branch + + +def test_tag_push_webhook_data_path(get_event_data, generate_commit_data, faker): + commit_hash = faker.md5() + path = faker.uri() + data = get_event_data( + GitlabEvent.TAG_PUSH, + { + "checkout_sha": commit_hash, + "commits": [ + generate_commit_data(), + generate_commit_data( + { + "id": commit_hash, + "url": path, + } + ), + ], + }, + ) + instance = TagWebhookModel(**data) + assert instance.path == path diff --git a/tests/units/secbot/__init__.py b/tests/units/secbot/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/tests/units/secbot/test_autodiscover.py b/tests/units/secbot/test_autodiscover.py new file mode 100755 index 0000000..7ae8ec4 --- /dev/null +++ b/tests/units/secbot/test_autodiscover.py @@ -0,0 +1,20 @@ +from unittest import mock + +from app.secbot import SecurityBot +from app.secbot.inputs.gitlab import GitlabInput + + +def test_autodiscover_gitlab(): + celery_app = mock.Mock() + runner = SecurityBot(celery_app=celery_app) + + assert "gitlab" in runner._registered_inputs + + +def test_gitlab_autodiscover_inputs(): + celery_app = mock.Mock() + gitlab_input = GitlabInput(config_name="gitlab", celery_app=celery_app) + + assert "gitleaks" in gitlab_input.scans + assert "defectdojo" in gitlab_input.outputs + assert "slack" in gitlab_input.notifications diff --git a/tests/units/secbot/test_register.py b/tests/units/secbot/test_register.py new file mode 100755 index 0000000..ada7200 --- /dev/null +++ b/tests/units/secbot/test_register.py @@ -0,0 +1,37 @@ +from unittest import mock + +from app.secbot import SecurityBot +from app.secbot.handlers import SecbotScanHandler +from app.secbot.inputs import SecbotInput +from app.secbot.inputs.gitlab import GitlabInput + + +def test_register_new_input(): + celery_app = mock.Mock() + init_mock = mock.Mock(return_value=None) + + class ExampleInput(SecbotInput): + __init__ = init_mock + + runner = SecurityBot(celery_app=celery_app) + runner.register_input("new_input", ExampleInput) + + assert "new_input" in runner._registered_inputs + init_mock.assert_called_once_with(config_name="new_input", celery_app=celery_app) + + +def test_register_new_handler(): + celery_app = mock.Mock() + init_mock = mock.Mock(return_value=None) + + class ExampleScanHandler(SecbotScanHandler): + __init__ = init_mock + + async def run(self, *args, **kwargs): + pass + + gitlab_input = GitlabInput(config_name="gitlab", celery_app=celery_app) + gitlab_input.register_handler("new_handler", ExampleScanHandler) + + assert "new_handler" in gitlab_input.scans + init_mock.assert_called_once_with(config_name="new_handler", celery_app=celery_app) diff --git a/tests/units/test_pydantic_celery.py b/tests/units/test_pydantic_celery.py new file mode 100755 index 0000000..08fe83b --- /dev/null +++ b/tests/units/test_pydantic_celery.py @@ -0,0 +1,95 @@ +from unittest import mock + +from app.secbot.schemas import SecbotBaseModel +from app.secbot.utils import deserializer, load_cls, serializer + + +class Example(SecbotBaseModel): + foo: str + + +def test_load_cls(): + cls = load_cls("tests.units.test_pydantic_celery.Example") + assert cls == Example + + +def test_serializer_with_simple_value(faker): + value = faker.pystr() + assert value == serializer(value) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_serializer_with_pydantic_model(faker): + model_path = "tests.units.test_pydantic_celery.Example" + model = {"foo": "bar", "pydantic_field": model_path} + assert Example(foo="bar") == serializer(model) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_serializer_with_args(faker): + model_path = "tests.units.test_pydantic_celery.Example" + model = {"foo": "bar", "pydantic_field": model_path} + + example_int = faker.pyint() + example_str = faker.pystr() + args = (example_int, example_str, model) + + assert (example_int, example_str, Example(foo="bar")) == serializer(args) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_serializer_with_kwargs(faker): + model_path = "tests.units.test_pydantic_celery.Example" + model = {"foo": "bar", "pydantic_field": model_path} + + example_int = faker.pyint() + example_str = faker.pystr() + kwargs = {"int": example_int, "str": example_str, "model": model} + + assert { + "int": example_int, + "str": example_str, + "model": Example(foo="bar"), + } == serializer(kwargs) + + +def test_deserializer_with_simple_value(faker): + value = faker.pystr() + assert value == deserializer(value) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_deserializer_with_pydantic_model(): + model = Example(foo="bar") + assert { + "foo": "bar", + "pydantic_field": "tests.units.test_pydantic_celery.Example", + } == deserializer(model) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_deserializer_with_args(faker): + example_int = faker.pyint() + example_str = faker.pystr() + args = (example_int, example_str, Example(foo="bar")) + + assert ( + example_int, + example_str, + {"foo": "bar", "pydantic_field": "tests.units.test_pydantic_celery.Example"}, + ) == deserializer(args) + + +@mock.patch("app.secbot.schemas.PYDANTIC_CLS_PATH", new="pydantic_field") +def test_deserializer_with_kwargs(faker): + example_int = faker.pyint() + example_str = faker.pystr() + kwargs = {"int": example_int, "str": example_str, "model": Example(foo="bar")} + assert { + "int": example_int, + "str": example_str, + "model": { + "foo": "bar", + "pydantic_field": "tests.units.test_pydantic_celery.Example", + }, + } == deserializer(kwargs) diff --git a/tests/units/test_worker_utils.py b/tests/units/test_worker_utils.py new file mode 100755 index 0000000..14664ea --- /dev/null +++ b/tests/units/test_worker_utils.py @@ -0,0 +1,22 @@ +from unittest.mock import patch + +from app.secbot.inputs.gitlab.services import get_gitlab_project_languages +from tests.units import factories + + +@patch("app.secbot.inputs.gitlab.services.requests") +@patch("app.secbot.inputs.gitlab.services.get_config_from_host") +def test_gitlab_language(_config_mock, requests_mock): + project = factories.create_project__security() + requests_mock.get.return_value.status_code = 200 + requests_mock.get.return_value.json.return_value = { + "Python": 52.01, + "Javascript": 47.98, + "Go": 0.01, + } + languages = get_gitlab_project_languages(project) + + requests_mock.get.assert_called_once() + assert len(languages.keys()) >= 3 + assert "Python" in languages.keys() + assert languages["Python"] > 50.0 diff --git a/tests/units/workflow/test_workflow_runner.py b/tests/units/workflow/test_workflow_runner.py new file mode 100755 index 0000000..d900901 --- /dev/null +++ b/tests/units/workflow/test_workflow_runner.py @@ -0,0 +1,95 @@ +# import pytest +# import yaml +# +# from app.exceptions import SecbotConfigError +# from app.secbot.config import SecbotConfig +# from app.workflow import SecbotWorkflow, SecbotWorkflowRunner +# +# +# def test_register_workflow(): +# yaml_string = """ +# version: "1.0" +# components: +# gitleaks: +# handler_name: gitleaks +# defectdojo: +# handler_name: defectdojo +# slack: +# handler_name: slack +# jobs: +# - name: Example jobs +# rules: +# gitlab: +# scans: +# - gitleaks +# outputs: +# - defectdojo +# notifications: +# - slack +# """ # noqa: W291,E261 +# config = SecbotConfig(yaml.safe_load(yaml_string)) +# runner = SecbotWorkflowRunner(config=config) +# +# workflow = SecbotWorkflow(input_name="gitlab") +# runner.register_workflow(workflow) +# +# assert "gitlab" in runner.workflows[0].input_name +# +# +# def test_workflow_validation_without_components(): +# yaml_string = """ +# version: "1.0" +# components: +# gitleaks: +# handler_name: gitleaks +# defectdojo: +# handler_name: defectdojo +# slack: +# handler_name: slack +# jobs: +# - name: Example jobs +# rules: +# gitlab: +# scans: +# - gitleaks +# outputs: +# - defectdojo +# notifications: +# - slack +# """ # noqa: W291,E261 +# config = SecbotConfig(yaml.safe_load(yaml_string)) +# runner = SecbotWorkflowRunner(config=config) +# +# runner.validate() +# assert runner.is_validated is True +# +# +# def test_workflow_validation(): +# yaml_string = """ +# version: "1.0" +# components: +# gitleaks: +# handler_name: gitleaks +# defectdojo: +# handler_name: defectdojo +# slack: +# handler_name: slack +# jobs: +# - name: Example jobs +# rules: +# gitlab: +# scans: +# - gitleaks +# outputs: +# - defectdojo +# notifications: +# - slack +# """ # noqa: W291,E261 +# config = SecbotConfig(yaml.safe_load(yaml_string)) +# runner = SecbotWorkflowRunner(config=config) +# +# workflow = SecbotWorkflow(input_name="gitlab") +# runner.register_workflow(workflow) +# +# with pytest.raises(SecbotConfigError): +# runner.validate()