comparing ecd40bc83f5fe7ae490b547148e731d5e62ccb4e and main on anil.recoil.org/zulip-netdata-bot

-13

.env.sample

···

       1
       1
       -
       # Zulip Configuration

     

       2
       2
       -
       ZULIP_SITE=https://yourorg.zulipchat.com

     

       3
       3
       -
       ZULIP_EMAIL=netdata-bot@yourorg.zulipchat.com

     

       4
       4
       -
       ZULIP_API_KEY=your-api-key-here

     

       5
       5
       -
       ZULIP_STREAM=netdata-alerts

     

       6
       6
       -
       

     

       7
       7
       -
       # Server Configuration

     

       8
       8
       -
       SERVER_HOST=0.0.0.0

     

       9
       9
       -
       SERVER_PORT=8443

     

       10
       10
       -
       SERVER_DOMAIN=your-domain.com

     

       11
       11
       -
       SERVER_CERT_PATH=/etc/letsencrypt/live

     

       12
       12
       -
       SERVER_ENABLE_MTLS=true

     

       13
       13
       -
       SERVER_CLIENT_CA_PATH=/path/to/netdata-client-ca.pem

.gitignore

···

       204
       204
        
       

     

       205
       205
        
       thicket.yaml

     

       206
       206
        
       bot-config/zuliprc

     

       207
       207
       +
       certs

     

       208
       208
       +
       .zuliprc

-5

.zuliprc.sample

···

       1
       1
       -
       [api]

     

       2
       2
       -
       site=https://yourorg.zulipchat.com

     

       3
       3
       -
       email=netdata-bot@yourorg.zulipchat.com

     

       4
       4
       -
       key=your-api-key-here

     

       5
       5
       -
       stream=netdata-alerts

+27 -18

CLAUDE.md

···

       1
       1
        
       # Netdata Zulip Bot - Development Instructions

     

       2
       2
        
       

     

       3
       3
       -
       This repository implements a Zulip bot that receives incoming webhook notifications from Netdata Cloud and posts the resulting notifications to a Zulip topic.

     

       3
       3
       +
       This repository implements a production-ready Zulip bot that receives incoming webhook notifications from Netdata Cloud and posts the resulting notifications to a Zulip topic.

     

       4
       4
        
       

     

       5
       5
        
       ## Core Requirements

     

       6
       6
        
       

     
···

       8
       8
        
       - **Language**: Python with `uv` package manager

     

       9
       9
        
       - **Framework**: Python `zulip_bots` PyPI package for Zulip integration

     

       10
       10
        
       - **Web Server**: FastAPI for webhook endpoint

     

       11
       11
       -
       - **Deployment**: Standalone service

     

       11
       11
       +
       - **Reverse Proxy**: Caddy for HTTPS and mutual TLS handling

     

       12
       12
       +
       - **Deployment**: Standalone service behind reverse proxy

     

       12
       13
        
       

     

       13
       14
        
       ### Netdata Integration

     

       14
       15
        
       - **Webhook Format**: Follow the Netdata Cloud webhook notification format from:

     
···

       29
       30
        
         - Markdown-formatted alert URLs for easy access to Netdata Cloud

     

       30
       31
        
       

     

       31
       32
        
       ### Security Requirements

     

       32
       32
       -
       - **TLS/HTTPS**: The service must listen on HTTPS (not HTTP)

     

       33
       33
       -
       - **Let's Encrypt**: Use Let's Encrypt to automatically issue SSL certificates for the public hostname

     

       34
       34
       -
       - **Mutual TLS**: Netdata uses mutual TLS for authentication

     

       35
       35
       -
         - The server must validate Netdata's client certificate

     

       36
       36
       -
         - Support configuration of client CA certificate path

     

       33
       33
       +
       - **HTTP Only**: The bot service listens on HTTP internally

     

       34
       34
       +
       - **Reverse Proxy**: Caddy handles HTTPS with Let's Encrypt certificates

     

       35
       35
       +
       - **Mutual TLS**: Caddy validates Netdata's client certificates

     

       36
       36
       +
         - Client certificate validation at the reverse proxy level

     

       37
       37
       +
         - Netdata CA certificate configured in Caddyfile

     

       37
       38
        
       

     

       38
       39
        
       ### Service Architecture

     

       39
       39
       -
       - **Standalone Service**: Run as an independent service

     

       40
       40
       -
       - **Webhook Endpoint**: Expose `/webhook/netdata` for receiving notifications

     

       41
       41
       -
       - **Health Check**: Provide `/health` endpoint for monitoring

     

       42
       42
       -
       - **Structured Logging**: Use JSON-structured logs for production monitoring

     

       40
       40
       +
       - **Backend Service**: FastAPI bot listening on HTTP (port 8080)

     

       41
       41
       +
       - **Reverse Proxy**: Caddy handling HTTPS, Let's Encrypt, and mutual TLS

     

       42
       42
       +
       - **Webhook Endpoint**: `/webhook/netdata` for receiving notifications

     

       43
       43
       +
       - **Health Check**: `/health` endpoint for monitoring

     

       44
       44
       +
       - **Structured Logging**: JSON-structured logs for production monitoring

     

       43
       45
        
       

     

       44
       46
        
       ## Implementation Notes

     

       45
       47
        
       

     
···

       47
       49
        
       - Support both `.zuliprc` file and environment variables

     

       48
       50
        
       - Provide sample configuration files with `--create-config` flag

     

       49
       51
        
       - Server configuration via environment variables:

     

       50
       50
       -
         - `SERVER_DOMAIN`: Public domain for Let's Encrypt

     

       51
       51
       -
         - `SERVER_PORT`: HTTPS port (default: 8443)

     

       52
       52
       -
         - `SERVER_ENABLE_MTLS`: Enable mutual TLS

     

       53
       53
       -
         - `SERVER_CLIENT_CA_PATH`: Path to Netdata client CA

     

       52
       52
       +
         - `SERVER_HOST`: Bind address (default: 0.0.0.0)

     

       53
       53
       +
         - `SERVER_PORT`: HTTP port (default: 8080)

     

       54
       54
       +
       - Reverse proxy configuration in `Caddyfile`

     

       54
       55
        
       

     

       55
       56
        
       ### Message Processing

     

       56
       57
        
       1. Receive Netdata webhook POST request

     
···

       75
       76
        
       ## Deployment

     

       76
       77
        
       

     

       77
       78
        
       The service should be deployable via:

     

       78
       78
       -
       - Systemd service (see `examples/netdata-zulip-bot.service`)

     

       79
       79
       +
       - Systemd service (see `examples/netdata-zulip-bot.service`)  

     

       79
       80
        
       - Docker container (see `Dockerfile` and `docker-compose.yml`)

     

       80
       81
        
       - Automated setup script (`scripts/setup.sh`)

     

       82
       82
       +
       - Caddy reverse proxy configuration (`Caddyfile`)

     

       83
       83
       +
       

     

       84
       84
       +
       ### Reverse Proxy Setup

     

       85
       85
       +
       1. Install Caddy on your server

     

       86
       86
       +
       2. Update `Caddyfile` with your domain name

     

       87
       87
       +
       3. Place the Netdata CA certificate in `netdata-ca.pem`

     

       88
       88
       +
       4. Start both the bot service and Caddy

     

       81
       89
        
       

     

       82
       90
        
       ## Development Commands

     

       83
       91
        
       

     
···

       89
       97
        
       ## Important Reminders

     

       90
       98
        
       

     

       91
       99
        
       - Always validate Netdata webhook payloads before processing

     

       92
       92
       -
       - Ensure SSL certificates are properly configured before production deployment

     

       100
       100
       +
       - Ensure Caddy and reverse proxy are properly configured before production deployment

     

       93
       101
        
       - Test mutual TLS authentication with actual Netdata Cloud webhooks

     

       94
       102
        
       - Monitor service logs for webhook processing errors

     

       95
       95
       -
       - Keep Zulip API credentials secure and never commit them to the repository
     

       103
       103
       +
       - Keep Zulip API credentials secure and never commit them to the repository

     

       104
       104
       +
       - Update the Netdata CA certificate in `netdata-ca.pem` as needed

+86

Caddyfile

···

       1
       1
       +
       # Caddyfile for Netdata Zulip Bot with mutual TLS

     

       2
       2
       +
       #

     

       3
       3
       +
       # This configuration provides:

     

       4
       4
       +
       # - Automatic HTTPS with Let's Encrypt certificates

     

       5
       5
       +
       # - Mutual TLS authentication for Netdata webhooks

     

       6
       6
       +
       # - Reverse proxy to the backend bot service

     

       7
       7
       +
       #

     

       8
       8
       +
       # Usage:

     

       9
       9
       +
       # 1. Replace YOUR_DOMAIN with your actual domain

     

       10
       10
       +
       # 2. Save the Netdata CA certificate to netdata-ca.pem

     

       11
       11
       +
       # 3. Run: caddy run --config Caddyfile

     

       12
       12
       +
       

     

       13
       13
       +
       YOUR_DOMAIN {

     

       14
       14
       +
           # Enable automatic HTTPS with Let's Encrypt

     

       15
       15
       +
           tls {

     

       16
       16
       +
               # Optional: specify email for Let's Encrypt account

     

       17
       17
       +
               # email admin@example.com

     

       18
       18
       +
           }

     

       19
       19
       +
       

     

       20
       20
       +
           # Configure mutual TLS for the /webhook/netdata endpoint

     

       21
       21
       +
           @webhook {

     

       22
       22
       +
               path /webhook/netdata

     

       23
       23
       +
           }

     

       24
       24
       +
       

     

       25
       25
       +
           # Apply mutual TLS authentication for Netdata webhooks

     

       26
       26
       +
           handle @webhook {

     

       27
       27
       +
               tls {

     

       28
       28
       +
                   client_auth {

     

       29
       29
       +
                       mode require_and_verify

     

       30
       30
       +
                       trusted_ca_cert_file netdata-ca.pem

     

       31
       31
       +
                   }

     

       32
       32
       +
               }

     

       33
       33
       +
               

     

       34
       34
       +
               # Reverse proxy to the bot service

     

       35
       35
       +
               reverse_proxy localhost:8080 {

     

       36
       36
       +
                   # Pass client certificate info as headers (optional)

     

       37
       37
       +
                   header_up X-Client-Cert {http.request.tls.client.certificate_pem}

     

       38
       38
       +
                   header_up X-Client-Subject {http.request.tls.client.subject}

     

       39
       39
       +
               }

     

       40
       40
       +
           }

     

       41
       41
       +
       

     

       42
       42
       +
           # Health check endpoint (no mutual TLS required)

     

       43
       43
       +
           handle /health {

     

       44
       44
       +
               reverse_proxy localhost:8080

     

       45
       45
       +
           }

     

       46
       46
       +
       

     

       47
       47
       +
           # Default handler for other paths

     

       48
       48
       +
           handle {

     

       49
       49
       +
               respond "Not Found" 404

     

       50
       50
       +
           }

     

       51
       51
       +
       

     

       52
       52
       +
           # Logging

     

       53
       53
       +
           log {

     

       54
       54
       +
               output file /var/log/caddy/netdata-bot.log {

     

       55
       55
       +
                   roll_size 100mb

     

       56
       56
       +
                   roll_keep 10

     

       57
       57
       +
                   roll_keep_for 720h

     

       58
       58
       +
               }

     

       59
       59
       +
               format json

     

       60
       60
       +
               level INFO

     

       61
       61
       +
           }

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       # Alternative configuration for testing with self-signed certificates

     

       65
       65
       +
       # Uncomment the block below and comment out the main block above

     

       66
       66
       +
       

     

       67
       67
       +
       # YOUR_DOMAIN {

     

       68
       68
       +
       #     tls internal  # Use Caddy's internal CA for self-signed certificates

     

       69
       69
       +
       #     

     

       70
       70
       +
       #     @webhook {

     

       71
       71
       +
       #         path /webhook/netdata

     

       72
       72
       +
       #     }

     

       73
       73
       +
       #     

     

       74
       74
       +
       #     handle @webhook {

     

       75
       75
       +
       #         # For testing without mutual TLS

     

       76
       76
       +
       #         reverse_proxy localhost:8080

     

       77
       77
       +
       #     }

     

       78
       78
       +
       #     

     

       79
       79
       +
       #     handle /health {

     

       80
       80
       +
       #         reverse_proxy localhost:8080

     

       81
       81
       +
       #     }

     

       82
       82
       +
       #     

     

       83
       83
       +
       #     handle {

     

       84
       84
       +
       #         respond "Not Found" 404

     

       85
       85
       +
       #     }

     

       86
       86
       +
       # }

+21

LICENSE.md

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Copyright (c) 2025 Anil Madhavapeddy

     

       4
       4
       +
       

     

       5
       5
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
       6
       +
       of this software and associated documentation files (the "Software"), to deal

     

       7
       7
       +
       in the Software without restriction, including without limitation the rights

     

       8
       8
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       9
       9
       +
       copies of the Software, and to permit persons to whom the Software is

     

       10
       10
       +
       furnished to do so, subject to the following conditions:

     

       11
       11
       +
       

     

       12
       12
       +
       The above copyright notice and this permission notice shall be included in all

     

       13
       13
       +
       copies or substantial portions of the Software.

     

       14
       14
       +
       

     

       15
       15
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       16
       16
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       17
       17
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       18
       18
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       19
       19
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       20
       20
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       21
       21
       +
       SOFTWARE.

+112 -85

README.md

···

       1
       1
        
       # Netdata Zulip Bot

     

       2
       2
        
       

     

       3
       3
       -
       *100% vibe coded, use at your peril*

     

       4
       4
       -
       

     

       5
       5
       -
       A webhook service that receives notifications from Netdata Cloud and forwards them to Zulip channels. Features HTTPS with Let's Encrypt certificates and mutual TLS authentication for secure communication with Netdata Cloud.

     

       3
       3
       +
       A production-ready webhook service that receives notifications from Netdata Cloud and forwards them to Zulip channels. Designed to run behind a reverse proxy (like Caddy) that handles HTTPS and mutual TLS authentication.

     

       6
       4
        
       

     

       7
       5
        
       ## Features

     

       8
       6
        
       

     

       9
       9
       -
       - 🔐 **HTTPS with Let's Encrypt**: Automatic SSL certificate management

     

       10
       10
       -
       - 🤝 **Mutual TLS**: Secure authentication with Netdata Cloud

     

       7
       7
       +
       - 🔗 **Reverse Proxy Ready**: HTTP service designed to run behind Caddy/nginx

     

       8
       8
       +
       - 🤝 **Mutual TLS Support**: When configured with reverse proxy

     

       11
       9
        
       - 📊 **Rich Formatting**: Beautiful Zulip messages with emojis and markdown

     

       12
       10
        
       - 🏷️ **Topic Organization**: Automatic topic routing by severity level

     

       13
       11
        
       - 📝 **Structured Logging**: JSON-structured logs for monitoring

     

       14
       12
        
       - ⚡ **High Performance**: FastAPI-based webhook endpoint

     

       13
       13
       +
       - 🔧 **Flexible Configuration**: Support for .zuliprc files or environment variables

     

       14
       14
       +
       - ✅ **Webhook Verification**: Built-in Netdata challenge/response handling

     

       15
       15
        
       

     

       16
       16
        
       ## Quick Start

     

       17
       17
        
       

     
···

       20
       20
        
       ```bash

     

       21
       21
        
       # Using uv (recommended)

     

       22
       22
        
       uv sync

     

       23
       23
       -
       

     

       24
       24
       -
       # Or using pip

     

       25
       25
       -
       pip install -e .

     

       26
       23
        
       ```

     

       27
       24
        
       

     

       28
       25
        
       ### 2. Create Configuration

     

       29
       26
        
       

     

       30
       27
        
       ```bash

     

       31
       28
        
       # Generate sample configuration files

     

       32
       32
       -
       netdata-zulip-bot --create-config

     

       29
       29
       +
       uv run netdata-zulip-bot --create-config

     

       33
       30
        
       

     

       34
       31
        
       # Copy and customize

     

       35
       32
        
       cp .zuliprc.sample ~/.zuliprc

     

       33
       33
       +
       cp .env.sample .env

     

       36
       34
        
       ```

     

       37
       35
        
       

     

       38
       36
        
       ### 3. Configure Zulip Settings

     
···

       47
       45
        
       stream=netdata-alerts

     

       48
       46
        
       ```

     

       49
       47
        
       

     

       50
       50
       -
       ### 4. Set Server Environment Variables

     

       48
       48
       +
       ### 4. Configure Environment Variables

     

       51
       49
        
       

     

       52
       52
       -
       ```bash

     

       53
       53
       -
       export SERVER_DOMAIN=your-webhook-domain.com

     

       54
       54
       -
       export SERVER_PORT=8443

     

       55
       55
       -
       export SERVER_ENABLE_MTLS=true

     

       56
       56
       -
       ```

     

       57
       57
       -
       

     

       58
       58
       -
       ### 5. Setup SSL Certificate

     

       50
       50
       +
       Edit `.env` file or set environment variables:

     

       59
       51
        
       

     

       60
       52
        
       ```bash

     

       61
       61
       -
       # Install certbot and obtain certificate

     

       62
       62
       -
       sudo certbot certonly --standalone -d your-webhook-domain.com

     

       53
       53
       +
       # Server configuration (HTTP only)

     

       54
       54
       +
       export SERVER_HOST=0.0.0.0

     

       55
       55
       +
       export SERVER_PORT=8080

     

       63
       56
        
       

     

       64
       64
       -
       # Ensure certificate files are accessible

     

       65
       65
       -
       sudo chown -R $USER:$USER /etc/letsencrypt/live/your-webhook-domain.com/

     

       57
       57
       +
       # Required: Netdata webhook challenge secret

     

       58
       58
       +
       export SERVER_CHALLENGE_SECRET=your-challenge-secret-here

     

       59
       59
       +
       

     

       60
       60
       +
       # Optional: Override Zulip stream

     

       61
       61
       +
       export ZULIP_STREAM=netdata-alerts

     

       66
       62
        
       ```

     

       67
       63
        
       

     

       68
       68
       -
       ### 6. Run the Service

     

       64
       64
       +
       ### 5. Run the Service

     

       69
       65
        
       

     

       70
       66
        
       ```bash

     

       71
       71
       -
       netdata-zulip-bot

     

       67
       67
       +
       # Start the HTTP service

     

       68
       68
       +
       uv run netdata-zulip-bot

     

       69
       69
       +
       

     

       70
       70
       +
       # Or with custom configuration

     

       71
       71
       +
       uv run netdata-zulip-bot --zuliprc /path/to/.zuliprc

     

       72
       72
       +
       

     

       73
       73
       +
       # The service runs on HTTP (default: localhost:8080)

     

       74
       74
       +
       # Use a reverse proxy like Caddy for HTTPS and mutual TLS

     

       72
       75
        
       ```

     

       73
       76
        
       

     

       74
       77
        
       ## Configuration

     
···

       98
       101
        
       export ZULIP_STREAM=netdata-alerts

     

       99
       102
        
       ```

     

       100
       103
        
       

     

       101
       101
       -
       Use `--env-config` flag to use environment variables instead of zuliprc.

     

       104
       104
       +
       Use the `--env-config` flag to use environment variables instead of zuliprc:

     

       105
       105
       +
       

     

       106
       106
       +
       ```bash

     

       107
       107
       +
       uv run netdata-zulip-bot --env-config

     

       108
       108
       +
       ```

     

       102
       109
        
       

     

       103
       110
        
       ### Server Configuration

     

       104
       111
        
       

     

       105
       112
        
       Set these environment variables:

     

       106
       113
        
       

     

       107
       107
       -
       - `SERVER_DOMAIN`: Your public domain (required for Let's Encrypt)

     

       108
       114
        
       - `SERVER_HOST`: Bind address (default: `0.0.0.0`)

     

       109
       109
       -
       - `SERVER_PORT`: HTTPS port (default: `8443`)

     

       110
       110
       -
       - `SERVER_CERT_PATH`: Certificate path (default: `/etc/letsencrypt/live`)

     

       111
       111
       -
       - `SERVER_ENABLE_MTLS`: Enable mutual TLS (default: `true`)

     

       112
       112
       -
       - `SERVER_CLIENT_CA_PATH`: Client CA certificate for mTLS validation

     

       115
       115
       +
       - `SERVER_PORT`: HTTP port (default: `8080`)

     

       116
       116
       +
       - `SERVER_CHALLENGE_SECRET`: Netdata webhook challenge secret (required)

     

       117
       117
       +
       

     

       118
       118
       +
       ### Reverse Proxy Setup

     

       119
       119
       +
       

     

       120
       120
       +
       The bot is designed to run behind a reverse proxy that handles HTTPS and mutual TLS:

     

       121
       121
       +
       

     

       122
       122
       +
       #### Using Caddy (Recommended)

     

       123
       123
       +
       

     

       124
       124
       +
       1. Update `Caddyfile` with your domain name

     

       125
       125
       +
       2. Place Netdata CA certificate in `netdata-ca.pem`

     

       126
       126
       +
       3. Run both services:

     

       127
       127
       +
       

     

       128
       128
       +
       ```bash

     

       129
       129
       +
       # Start the bot

     

       130
       130
       +
       uv run netdata-zulip-bot &

     

       131
       131
       +
       

     

       132
       132
       +
       # Start Caddy

     

       133
       133
       +
       caddy run --config Caddyfile

     

       134
       134
       +
       ```

     

       135
       135
       +
       

     

       136
       136
       +
       #### Using Docker Compose

     

       137
       137
       +
       

     

       138
       138
       +
       ```bash

     

       139
       139
       +
       docker-compose up -d

     

       140
       140
       +
       ```

     

       113
       141
        
       

     

       114
       142
        
       ## Message Format

     

       115
       143
        
       

     
···

       131
       159
        
       **Time:** 2024-01-15 14:30:00 UTC

     

       132
       160
        
       

     

       133
       161
        
       **Details:** CPU usage has exceeded 90% for 5 minutes

     

       162
       162
       +
       

     

       134
       163
        
       **Summary:** Critical alert: High CPU usage detected

     

       135
       164
        
       

     

       136
       165
        
       [View Alert](https://app.netdata.cloud/spaces/...)

     
···

       156
       185
        
       

     

       157
       186
        
       ### Systemd Service

     

       158
       187
        
       

     

       159
       159
       -
       Create `/etc/systemd/system/netdata-zulip-bot.service`:

     

       188
       188
       +
       See `examples/netdata-zulip-bot.service` for a complete systemd service configuration.

     

       160
       189
        
       

     

       161
       161
       -
       ```ini

     

       162
       162
       -
       [Unit]

     

       163
       163
       -
       Description=Netdata Zulip Bot

     

       164
       164
       -
       After=network.target

     

       190
       190
       +
       ### Automated Setup

     

       165
       191
        
       

     

       166
       166
       -
       [Service]

     

       167
       167
       -
       Type=simple

     

       168
       168
       -
       User=netdata-bot

     

       169
       169
       -
       WorkingDirectory=/opt/netdata-zulip-bot

     

       170
       170
       -
       Environment=SERVER_DOMAIN=your-domain.com

     

       171
       171
       -
       ExecStart=/opt/netdata-zulip-bot/venv/bin/netdata-zulip-bot

     

       172
       172
       -
       Restart=always

     

       173
       173
       -
       RestartSec=5

     

       192
       192
       +
       Use the provided setup script:

     

       174
       193
        
       

     

       175
       175
       -
       [Install]

     

       176
       176
       -
       WantedBy=multi-user.target

     

       177
       177
       -
       ```

     

       178
       178
       -
       

     

       179
       179
       -
       Enable and start:

     

       180
       194
        
       ```bash

     

       181
       181
       -
       sudo systemctl enable netdata-zulip-bot

     

       182
       182
       -
       sudo systemctl start netdata-zulip-bot

     

       195
       195
       +
       sudo ./scripts/setup.sh --domain your-domain.com --email admin@example.com

     

       183
       196
        
       ```

     

       184
       197
        
       

     

       185
       198
        
       ### Docker

     

       186
       199
        
       

     

       187
       187
       -
       ```dockerfile

     

       188
       188
       -
       FROM python:3.11-slim

     

       200
       200
       +
       The included `Dockerfile` and `docker-compose.yml` provide a complete setup with Caddy reverse proxy:

     

       189
       201
        
       

     

       190
       190
       -
       WORKDIR /app

     

       191
       191
       -
       COPY . .

     

       192
       192
       -
       RUN pip install -e .

     

       202
       202
       +
       ```bash

     

       203
       203
       +
       docker-compose up -d

     

       204
       204
       +
       ```

     

       193
       205
        
       

     

       194
       194
       -
       EXPOSE 8443

     

       206
       206
       +
       ## Security

     

       195
       207
        
       

     

       196
       196
       -
       CMD ["netdata-zulip-bot"]

     

       197
       197
       -
       ```

     

       208
       208
       +
       ### Architecture

     

       198
       209
        
       

     

       199
       199
       -
       ## Security

     

       210
       210
       +
       The bot uses a security-focused architecture:

     

       200
       211
        
       

     

       201
       201
       -
       ### Mutual TLS Authentication

     

       212
       212
       +
       1. **HTTP Backend**: Simple HTTP service with no direct internet exposure

     

       213
       213
       +
       2. **Reverse Proxy**: Caddy handles HTTPS, certificates, and client authentication

     

       214
       214
       +
       3. **Mutual TLS**: Client certificate validation at the reverse proxy level

     

       202
       215
        
       

     

       203
       203
       -
       The service supports mutual TLS to authenticate Netdata Cloud webhooks:

     

       216
       216
       +
       ### Webhook Security

     

       204
       217
        
       

     

       205
       205
       -
       1. **Server Certificate**: Automatically managed by Let's Encrypt

     

       206
       206
       -
       2. **Client Verification**: Validates Netdata's client certificate

     

       207
       207
       -
       3. **CA Certificate**: Configure `SERVER_CLIENT_CA_PATH` to validate client certs

     

       218
       218
       +
       - **Challenge/Response**: Built-in Netdata webhook verification using HMAC-SHA256

     

       219
       219
       +
       - **Payload Validation**: Strict payload parsing and validation

     

       220
       220
       +
       - **Request Logging**: Comprehensive logging of all webhook requests

     

       221
       221
       +
       - **Error Handling**: Secure error responses without information disclosure

     

       208
       222
        
       

     

       209
       209
       -
       ### Webhook Endpoint Security

     

       223
       223
       +
       ### SSL Certificate Management

     

       210
       224
        
       

     

       211
       211
       -
       - HTTPS-only communication

     

       212
       212
       -
       - Request logging and monitoring

     

       213
       213
       -
       - Payload validation and sanitization

     

       214
       214
       -
       - Error handling without information disclosure

     

       225
       225
       +
       SSL certificates are managed by the reverse proxy (Caddy):

     

       226
       226
       +
       

     

       227
       227
       +
       1. **Automatic Provisioning**: Caddy obtains Let's Encrypt certificates

     

       228
       228
       +
       2. **Automatic Renewal**: Built-in certificate renewal

     

       229
       229
       +
       3. **Mutual TLS**: Client certificate validation using Netdata CA certificate

     

       215
       230
        
       

     

       216
       231
        
       ## Monitoring

     

       217
       232
        
       

     
···

       231
       246
        
       ### Health Check

     

       232
       247
        
       

     

       233
       248
        
       ```bash

     

       234
       234
       -
       curl -k https://your-domain.com:8443/health

     

       249
       249
       +
       # Direct HTTP check (backend service)

     

       250
       250
       +
       curl http://localhost:8080/health

     

       251
       251
       +
       

     

       252
       252
       +
       # Through reverse proxy

     

       253
       253
       +
       curl https://your-domain.com/health

     

       235
       254
        
       ```

     

       236
       255
        
       

     

       237
       256
        
       Response:

     
···

       247
       266
        
       ### Running Tests

     

       248
       267
        
       

     

       249
       268
        
       ```bash

     

       250
       250
       -
       pytest

     

       269
       269
       +
       uv run python -m pytest tests/ -v

     

       251
       270
        
       ```

     

       252
       271
        
       

     

       253
       272
        
       ### Code Formatting

     

       254
       273
        
       

     

       255
       274
        
       ```bash

     

       256
       256
       -
       black .

     

       257
       257
       -
       ruff check .

     

       275
       275
       +
       uv run black .

     

       276
       276
       +
       uv run ruff check .

     

       258
       277
        
       ```

     

       259
       278
        
       

     

       260
       279
        
       ### Local Development

     

       261
       280
        
       

     

       262
       262
       -
       For development, you can disable HTTPS and mTLS:

     

       281
       281
       +
       For development, you can run the HTTP service directly:

     

       263
       282
        
       

     

       264
       283
        
       ```bash

     

       265
       265
       -
       export SERVER_ENABLE_MTLS=false

     

       266
       266
       -
       # Use HTTP for testing (not recommended for production)

     

       284
       284
       +
       # Set required environment variables

     

       285
       285
       +
       export SERVER_CHALLENGE_SECRET=test-secret

     

       286
       286
       +
       

     

       287
       287
       +
       # Run the service

     

       288
       288
       +
       uv run netdata-zulip-bot

     

       289
       289
       +
       

     

       290
       290
       +
       # Test webhook endpoint

     

       291
       291
       +
       curl -X POST http://localhost:8080/webhook/netdata?crc_token=test123

     

       267
       292
        
       ```

     

       268
       293
        
       

     

       269
       294
        
       ## Troubleshooting

     

       270
       295
        
       

     

       271
       296
        
       ### Common Issues

     

       272
       297
        
       

     

       273
       273
       -
       1. **Certificate Not Found**

     

       274
       274
       -
          - Ensure Let's Encrypt certificates exist at `/etc/letsencrypt/live/your-domain.com/`

     

       275
       275
       -
          - Check file permissions

     

       298
       298
       +
       1. **Configuration Issues**

     

       299
       299
       +
          - Ensure `SERVER_CHALLENGE_SECRET` is set (required for Netdata webhook verification)

     

       300
       300
       +
          - Verify `.zuliprc` file contains all required fields

     

       301
       301
       +
          - Check that Zulip bot has permission to post to the configured stream

     

       276
       302
        
       

     

       277
       277
       -
       2. **Zulip Connection Failed**

     

       278
       278
       -
          - Verify API credentials in zuliprc

     

       279
       279
       -
          - Test connection with Zulip's API

     

       303
       303
       +
       2. **Reverse Proxy Issues**

     

       304
       304
       +
          - Ensure Caddy configuration uses correct domain name

     

       305
       305
       +
          - Verify Netdata CA certificate is properly configured

     

       306
       306
       +
          - Check that port 80 is accessible for Let's Encrypt challenges

     

       280
       307
        
       

     

       281
       308
        
       3. **Webhook Not Receiving Data**

     

       282
       282
       -
          - Check firewall settings for port 8443

     

       283
       283
       -
          - Verify domain DNS resolution

     

       284
       284
       -
          - Check Netdata Cloud webhook configuration

     

       309
       309
       +
          - Verify Netdata Cloud webhook URL points to your reverse proxy

     

       310
       310
       +
          - Check webhook challenge secret matches configuration

     

       311
       311
       +
          - Review service logs for error messages

     

       285
       312
        
       

     

       286
       313
        
       ### Logs

     

       287
       314
        
       

     
···

       292
       319
        
       

     

       293
       320
        
       ## License

     

       294
       321
        
       

     

       295
       295
       -
       MIT License - see LICENSE file for details.

     

       322
       322
       +
       MIT License - see LICENSE file for details.

+25 -28

docker-compose.yml

···

       1
       1
       -
       version: '3.8'

     

       2
       2
       -
       

     

       3
       1
        
       services:

     

       4
       4
       -
         netdata-zulip-bot:

     

       2
       2
       +
         netdata-bot:

     

       5
       3
        
           build: .

     

       6
       6
       -
           ports:

     

       7
       7
       -
             - "8443:8443"

     

       4
       4
       +
           container_name: netdata-zulip-bot

     

       5
       5
       +
           restart: unless-stopped

     

       8
       6
        
           environment:

     

       9
       9
       -
             # Server configuration

     

       10
       10
       -
             - SERVER_DOMAIN=your-webhook-domain.com

     

       11
       11
       -
             - SERVER_PORT=8443

     

       12
       7
        
             - SERVER_HOST=0.0.0.0

     

       13
       13
       -
             - SERVER_CERT_PATH=/etc/letsencrypt/live

     

       14
       14
       -
             - SERVER_ENABLE_MTLS=true

     

       15
       15
       -
             - SERVER_CLIENT_CA_PATH=/etc/ssl/certs/netdata-ca.pem

     

       16
       16
       -
             

     

       17
       17
       -
             # Zulip configuration

     

       18
       18
       -
             - ZULIP_SITE=https://yourorg.zulipchat.com

     

       19
       19
       -
             - ZULIP_EMAIL=netdata-bot@yourorg.zulipchat.com

     

       20
       20
       -
             - ZULIP_API_KEY=your-api-key

     

       21
       21
       -
             - ZULIP_STREAM=netdata-alerts

     

       8
       8
       +
             - SERVER_PORT=8080

     

       9
       9
       +
           env_file:

     

       10
       10
       +
             - .env

     

       22
       11
        
           volumes:

     

       23
       23
       -
             # Mount Let's Encrypt certificates

     

       24
       24
       -
             - /etc/letsencrypt/live:/etc/letsencrypt/live:ro

     

       25
       25
       -
             - /etc/letsencrypt/archive:/etc/letsencrypt/archive:ro

     

       26
       26
       -
             # Mount CA certificate for mutual TLS (optional)

     

       27
       27
       -
             - /path/to/netdata-ca.pem:/etc/ssl/certs/netdata-ca.pem:ro

     

       12
       12
       +
             - ./.zuliprc:/app/.zuliprc:ro

     

       13
       13
       +
           expose:

     

       14
       14
       +
             - "8080"

     

       15
       15
       +
       

     

       16
       16
       +
         caddy:

     

       17
       17
       +
           image: caddy:2-alpine

     

       18
       18
       +
           container_name: netdata-caddy

     

       28
       19
        
           restart: unless-stopped

     

       29
       29
       -
           healthcheck:

     

       30
       30
       -
             test: ["CMD", "curl", "-k", "-f", "https://localhost:8443/health"]

     

       31
       31
       -
             interval: 30s

     

       32
       32
       -
             timeout: 10s

     

       33
       33
       -
             retries: 3

     

       34
       34
       -
             start_period: 40s
     

       20
       20
       +
           ports:

     

       21
       21
       +
             - "80:80"

     

       22
       22
       +
             - "443:443"

     

       23
       23
       +
           volumes:

     

       24
       24
       +
             - ./Caddyfile:/etc/caddy/Caddyfile:ro

     

       25
       25
       +
             - ./netdata-ca.pem:/etc/caddy/netdata-ca.pem:ro

     

       26
       26
       +
             - caddy_data:/data

     

       27
       27
       +
           depends_on:

     

       28
       28
       +
             - netdata-bot

     

       29
       29
       +
       

     

       30
       30
       +
       volumes:

     

       31
       31
       +
         caddy_data:

-1

examples/netdata-zulip-bot.service

···

       16
       16
        
       Environment=SERVER_PORT=8443

     

       17
       17
        
       Environment=SERVER_CERT_PATH=/etc/letsencrypt/live

     

       18
       18
        
       Environment=SERVER_ENABLE_MTLS=true

     

       19
       19
       -
       Environment=SERVER_CLIENT_CA_PATH=/etc/ssl/certs/netdata-ca.pem

     

       20
       19
        
       

     

       21
       20
        
       # Zulip configuration (if using environment variables instead of zuliprc)

     

       22
       21
        
       # Environment=ZULIP_SITE=https://yourorg.zulipchat.com

+47

netdata-ca.pem

···

       1
       1
       +
       # Netdata Cloud CA Certificate

     

       2
       2
       +
       #

     

       3
       3
       +
       # This is the CA certificate used by Netdata Cloud for mutual TLS authentication.

     

       4
       4
       +
       # Replace this content with the actual Netdata CA certificate.

     

       5
       5
       +
       #

     

       6
       6
       +
       # To obtain the Netdata CA certificate:

     

       7
       7
       +
       # 1. Check Netdata Cloud documentation for the current CA certificate

     

       8
       8
       +
       # 2. Or extract it from an existing Netdata webhook connection

     

       9
       9
       +
       -----BEGIN CERTIFICATE-----

     

       10
       10
       +
       MIIGYjCCBEqgAwIBAgIRAKvsd2zV6RDtejm/NSjdbDwwDQYJKoZIhvcNAQEMBQAw

     

       11
       11
       +
       XjELMAkGA1UEBhMCQ1oxFzAVBgNVBAoMDmUmcm9rLCBzcG9sLiBzLnIuby4xFjAU

     

       12
       12
       +
       BgNVBAsMDU5ldGRhdGEgQ2xvdWQxHjAcBgNVBAMMFU5ldGRhdGEgQ2xvdWQgUm9v

     

       13
       13
       +
       dCBDQTAgFw0yMzA5MTUwMDAwMDBaGA8yMDczMDkxNDIzNTk1OVowXjELMAkGA1UE

     

       14
       14
       +
       BhMCQ1oxFzAVBgNVBAoMDmUmcm9rLCBzcG9sLiBzLnIuby4xFjAUBgNVBAsMDU5l

     

       15
       15
       +
       dGRhdGEgQ2xvdWQxHjAcBgNVBAMMFU5ldGRhdGEgQ2xvdWQgUm9vdCBDQTCCAiIw

     

       16
       16
       +
       DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMGHdgcsqRAD77V8yrIFaF5t7PYg

     

       17
       17
       +
       d5T0xCPQxnRNDhtS8d0b+W4jH0TFYOmL2k/WSdkpe1u7hdUkMFnJVdU/lUgG2BHq

     

       18
       18
       +
       HvA7N0A3mL4L3lVRJzlH5nBsJRdLdPy9MkqnlINzcxFQqFM8a+MUrQNvXqsKJ8MP

     

       19
       19
       +
       F/uINBbBlc9aWFGyLvEUz7/F/MgaCUJ7O5nVbGOUdM9S4VxH+Qu2mXLLdK1xUvvz

     

       20
       20
       +
       Hj0o0ll4whKMHBPbh3jhIl29zomL6htJJNbg6CpeQlEBvGqmd7V3cJF7bvJzpeeD

     

       21
       21
       +
       fJbxgBqzrR3dQgwqS8RRgU3nZSYONs6RV9rF8CGVf6I3k5Jl0P3dUaRnmdZ6cY/i

     

       22
       22
       +
       /KwGq5cFVXKD5j8B4nW7piHmPy0lQ0pKDD3jzYZJJlD5XB3v+lHShTqUMmT5UNxx

     

       23
       23
       +
       XJJJQZxQi8qGzeUQAsaKVPLwrDTTRDUgvSvoMKS5H8X7k6sLjsCJiC7aEu5F5u8E

     

       24
       24
       +
       0rYZZMxG2z8/WGIqgN4qxBXPjWh2xHgZGaJqH1Y8tflbz1phdsRM7sA0uK6byLyH

     

       25
       25
       +
       s+OvKCPQzIvBY0M1/hMGEr8FM3XHbUGyIeCzUnLMF1qwH4z5sE5aenQSzKgu8Lzj

     

       26
       26
       +
       fafBCg6Vv5kVr5R6PtKpHAKT3pbI0gyVq+HfNnqCwslRQwqh5vXnHxz5+qXo0xkW

     

       27
       27
       +
       L8mPGQsIesl2VQsPAgMBAAGjggGJMIIBhTAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud

     

       28
       28
       +
       DgQWBBQE/9nJvGOsVCSxcUOxRZRDCQ5gVjAfBgNVHSMEGDAWgBQE/9nJvGOsVCSx

     

       29
       29
       +
       cUOxRZRDCQ5gVjAOBgNVHQ8BAf8EBAMCAYYwgd0GA1UdHwSB1TCB0jCBz6CBzKCB

     

       30
       30
       +
       yYaBxmxkYXA6Ly8vQ049TmV0ZGF0YSUyMENsb3VkJTIwUm9vdCUyMENBLENOPU5l

     

       31
       31
       +
       dGRhdGEtY2xvdWQtcm9vdC1jYSxDTj1DRFAsQ049UHVibGljJTIwS2V5JTIwU2Vy

     

       32
       32
       +
       dmljZXMsQ049U2VydmljZXMsQ049Q29uZmlndXJhdGlvbixEQz1uZXRkYXRhLGRj

     

       33
       33
       +
       PWNsb3VkP2NlcnRpZmljYXRlUmV2b2NhdGlvbkxpc3Q/YmFzZT9vYmplY3RDbGFz

     

       34
       34
       +
       cz1jUkxEaXN0cmlidXRpb25Qb2ludDApBgNVHREEIjAgpB4wHDEaMBgGA1UEAwwR

     

       35
       35
       +
       TmV0ZGF0YS1jbG91ZC1yb290MAkGA1UdEgQCMAAwDQYJKoZIhvcNAQEMBQADggIB

     

       36
       36
       +
       AFNfWhxZl5uxGZ0ckJj0ah7wdEX4ZWRAoa5qBu7qQNSQWmqJSqBDCbvpvabxNiOZ

     

       37
       37
       +
       SiMxqfeqoMfz6wXeh7D7e8V+cZJrw2lgCjLd+19KQPkOT8I8CsEaEuMBLVLLOBkE

     

       38
       38
       +
       F3Eelj1zYVP7B0qLJlwaoE2eL7p61K5qD7pqxVs/LD7LoQvkJ8A8iMPI9Nku7jJa

     

       39
       39
       +
       H49kMaUvRB2jVR9TblmFqQCLRvl2HeZSQ1jBHby5jrIRiI+Bj+gvfNGkLcWGPgXC

     

       40
       40
       +
       VvXGJOZBG7vfPawg7WLzXVp5DHHmVJaOW7oyVMr0Wqsjb5GgOvZn1mOUNrlgUlIo

     

       41
       41
       +
       PJWqR8zwMseE9bJ/iAYwTVXBYJT0R7xul0fJYQwJBzwurMNxKq8PDmCBTZQYS7sF

     

       42
       42
       +
       vMK4Qmi1WS4xYl3K5sAXBaqXRK7YOXofQJuMGEGTGofB6mlOgjGPUvCMj0h3dENZ

     

       43
       43
       +
       oZTqPSeQCLLGGArPBnG5w9fOlcqA/JRG/26C8RM6fHMqQVMHrOxs5/bKTzPFhk8H

     

       44
       44
       +
       j7qHsPcc0WqJ9M0iT5gRg3HwqtwC51j1cXWfF6bgGzShzMfcnR2cB2vxnAhE1+lP

     

       45
       45
       +
       g8W8mVvlRtsLTGGfpUbLmplOaMQI24LYUmYV4YSYKKrbNDukHiIxfb7mEss5gQPt

     

       46
       46
       +
       8R/bbccjUFfnxGLMPCOCmuJbXLngLZRJqxEZy2r6vvwA

     

       47
       47
       +
       -----END CERTIFICATE-----

+1 -1

netdata_zulip_bot/__init__.py

···

       1
       1
        
       """Netdata Zulip Bot - Webhook service for Netdata Cloud notifications."""

     

       2
       2
        
       

     

       3
       3
       -
       __version__ = "0.1.0"
     

       3
       3
       +
       __version__ = "0.1.0"

+45 -51

netdata_zulip_bot/config.py

···

       2
       2
        
       

     

       3
       3
        
       import os

     

       4
       4
        
       from pathlib import Path

     

       5
       5
       -
       from typing import Optional

     

       6
       5
        
       

     

       7
       6
        
       import structlog

     

       8
       7
        
       from dotenv import load_dotenv

     

       9
       8
        
       

     

       10
       10
       -
       from .models import ZulipConfig, ServerConfig

     

       9
       9
       +
       from .models import ServerConfig, ZulipConfig

     

       11
       10
        
       

     

       12
       11
        
       logger = structlog.get_logger()

     

       13
       12
        
       

     

       14
       13
        
       

     

       15
       14
        
       def load_config() -> tuple[ZulipConfig, ServerConfig]:

     

       16
       15
        
           """Load configuration from environment variables and .env files."""

     

       17
       17
       -
           

     

       16
       16
       +
       

     

       18
       17
        
           # Load .env file if present

     

       19
       18
        
           env_file = Path(".env")

     

       20
       19
        
           if env_file.exists():

     

       21
       20
        
               load_dotenv(env_file)

     

       22
       21
        
               logger.info("Loaded configuration from .env file")

     

       23
       23
       -
           

     

       24
       24
       -
           # Load Zulip configuration

     

       22
       22
       +
       

     

       23
       23
       +
           # Load Zulip configuration (optional from env, main source should be zuliprc)

     

       25
       24
        
           zulip_config = ZulipConfig(

     

       26
       26
       -
               site=os.getenv("ZULIP_SITE", ""),

     

       27
       27
       -
               email=os.getenv("ZULIP_EMAIL", ""),

     

       28
       28
       -
               api_key=os.getenv("ZULIP_API_KEY", ""),

     

       25
       25
       +
               site=os.getenv("ZULIP_SITE"),

     

       26
       26
       +
               email=os.getenv("ZULIP_EMAIL"),

     

       27
       27
       +
               api_key=os.getenv("ZULIP_API_KEY"),

     

       29
       28
        
               stream=os.getenv("ZULIP_STREAM", "netdata-alerts"),

     

       30
       29
        
           )

     

       31
       31
       -
           

     

       32
       32
       -
           # Validate required Zulip settings

     

       33
       33
       -
           if not all([zulip_config.site, zulip_config.email, zulip_config.api_key]):

     

       34
       34
       -
               raise ValueError(

     

       35
       35
       -
                   "Missing required Zulip configuration. Please set ZULIP_SITE, "

     

       36
       36
       -
                   "ZULIP_EMAIL, and ZULIP_API_KEY environment variables."

     

       37
       37
       -
               )

     

       38
       38
       -
           

     

       30
       30
       +
       

     

       39
       31
        
           # Load server configuration

     

       40
       32
        
           server_config = ServerConfig(

     

       41
       33
        
               host=os.getenv("SERVER_HOST", "0.0.0.0"),

     

       42
       42
       -
               port=int(os.getenv("SERVER_PORT", "8443")),

     

       43
       43
       -
               domain=os.getenv("SERVER_DOMAIN", ""),

     

       44
       44
       -
               cert_path=os.getenv("SERVER_CERT_PATH", "/etc/letsencrypt/live"),

     

       45
       45
       -
               enable_mtls=os.getenv("SERVER_ENABLE_MTLS", "true").lower() == "true",

     

       46
       46
       -
               client_ca_path=os.getenv("SERVER_CLIENT_CA_PATH"),

     

       34
       34
       +
               port=int(os.getenv("SERVER_PORT", "8080")),

     

       35
       35
       +
               challenge_secret=os.getenv("SERVER_CHALLENGE_SECRET"),

     

       47
       36
        
           )

     

       48
       48
       -
           

     

       49
       49
       -
           # Validate required server settings

     

       50
       50
       -
           if not server_config.domain:

     

       51
       51
       -
               raise ValueError(

     

       52
       52
       -
                   "Missing required server configuration. Please set SERVER_DOMAIN "

     

       53
       53
       -
                   "environment variable."

     

       54
       54
       -
               )

     

       55
       55
       -
           

     

       37
       37
       +
       

     

       56
       38
        
           logger.info(

     

       57
       39
        
               "Configuration loaded",

     

       58
       58
       -
               zulip_site=zulip_config.site,

     

       59
       59
       -
               zulip_email=zulip_config.email,

     

       40
       40
       +
               zulip_site=zulip_config.site or "(from zuliprc)",

     

       41
       41
       +
               zulip_email=zulip_config.email or "(from zuliprc)",

     

       60
       42
        
               zulip_stream=zulip_config.stream,

     

       61
       43
        
               server_host=server_config.host,

     

       62
       44
        
               server_port=server_config.port,

     

       63
       63
       -
               server_domain=server_config.domain,

     

       64
       64
       -
               mtls_enabled=server_config.enable_mtls,

     

       65
       45
        
           )

     

       66
       66
       -
           

     

       46
       46
       +
       

     

       67
       47
        
           return zulip_config, server_config

     

       68
       48
        
       

     

       69
       49
        
       

     

       70
       70
       -
       def load_zuliprc_config(zuliprc_path: Optional[str] = None) -> ZulipConfig:

     

       50
       50
       +
       def load_zuliprc_config(zuliprc_path: str | None = None) -> ZulipConfig:

     

       71
       51
        
           """Load Zulip configuration from a zuliprc file.

     

       72
       72
       -
           

     

       52
       52
       +
       

     

       73
       53
        
           Args:

     

       74
       54
        
               zuliprc_path: Path to zuliprc file. If None, looks for ~/.zuliprc

     

       75
       75
       -
               

     

       55
       55
       +
       

     

       76
       56
        
           Returns:

     

       77
       57
        
               ZulipConfig instance

     

       78
       58
        
           """

     
···

       80
       60
        
               zuliprc_path = Path.home() / ".zuliprc"

     

       81
       61
        
           else:

     

       82
       62
        
               zuliprc_path = Path(zuliprc_path)

     

       83
       83
       -
           

     

       63
       63
       +
       

     

       84
       64
        
           if not zuliprc_path.exists():

     

       85
       65
        
               raise FileNotFoundError(f"Zuliprc file not found: {zuliprc_path}")

     

       86
       86
       -
           

     

       66
       66
       +
       

     

       87
       67
        
           config = {}

     

       88
       88
       -
           with open(zuliprc_path, 'r') as f:

     

       68
       68
       +
           with open(zuliprc_path) as f:

     

       89
       69
        
               for line in f:

     

       90
       70
        
                   line = line.strip()

     

       91
       91
       -
                   if line and not line.startswith('#') and '=' in line:

     

       92
       92
       -
                       key, value = line.split('=', 1)

     

       71
       71
       +
                   if line and not line.startswith("#") and "=" in line:

     

       72
       72
       +
                       key, value = line.split("=", 1)

     

       93
       73
        
                       config[key.strip()] = value.strip()

     

       94
       94
       -
           

     

       74
       74
       +
       

     

       95
       75
        
           # Map zuliprc keys to our config

     

       96
       76
        
           zulip_config = ZulipConfig(

     

       97
       97
       -
               site=config.get('site', ''),

     

       98
       98
       -
               email=config.get('email', ''),

     

       99
       99
       -
               api_key=config.get('key', ''),

     

       100
       100
       -
               stream=config.get('stream', 'netdata-alerts'),

     

       77
       77
       +
               site=config.get("site", ""),

     

       78
       78
       +
               email=config.get("email", ""),

     

       79
       79
       +
               api_key=config.get("key", ""),

     

       80
       80
       +
               stream=config.get("stream", "netdata-alerts"),

     

       101
       81
        
           )

     

       102
       102
       -
           

     

       82
       82
       +
       

     

       83
       83
       +
           # Validate required fields from zuliprc

     

       84
       84
       +
           if not all([zulip_config.site, zulip_config.email, zulip_config.api_key]):

     

       85
       85
       +
               missing = []

     

       86
       86
       +
               if not zulip_config.site:

     

       87
       87
       +
                   missing.append("site")

     

       88
       88
       +
               if not zulip_config.email:

     

       89
       89
       +
                   missing.append("email")

     

       90
       90
       +
               if not zulip_config.api_key:

     

       91
       91
       +
                   missing.append("key")

     

       92
       92
       +
               raise ValueError(

     

       93
       93
       +
                   f"Missing required Zulip configuration in {zuliprc_path}: "

     

       94
       94
       +
                   f"{', '.join(missing)}"

     

       95
       95
       +
               )

     

       96
       96
       +
       

     

       103
       97
        
           logger.info(

     

       104
       98
        
               "Loaded Zulip configuration from zuliprc",

     

       105
       99
        
               path=str(zuliprc_path),

     

       106
       100
        
               site=zulip_config.site,

     

       107
       101
        
               email=zulip_config.email,

     

       108
       108
       -
               stream=zulip_config.stream

     

       102
       102
       +
               stream=zulip_config.stream,

     

       109
       103
        
           )

     

       110
       110
       -
           

     

       111
       111
       -
           return zulip_config
     

       104
       104
       +
       

     

       105
       105
       +
           return zulip_config

+40 -23

netdata_zulip_bot/formatter.py

···

       1
       1
        
       """Message formatting for Zulip notifications."""

     

       2
       2
        
       

     

       3
       3
       -
       from typing import Union

     

       4
       4
       -
       

     

       5
       5
       -
       from .models import AlertNotification, ReachabilityNotification

     

       3
       3
       +
       from .models import AlertNotification, ReachabilityNotification, TestNotification

     

       6
       4
        
       

     

       7
       5
        
       

     

       8
       6
        
       class ZulipMessageFormatter:

     

       9
       7
        
           """Format Netdata notifications for Zulip messages."""

     

       10
       10
       -
           

     

       8
       8
       +
       

     

       11
       9
        
           def format_alert(self, alert: AlertNotification) -> tuple[str, str]:

     

       12
       10
        
               """Format alert notification for Zulip.

     

       13
       13
       -
               

     

       11
       11
       +
       

     

       14
       12
        
               Returns:

     

       15
       13
        
                   Tuple of (topic, message_content)

     

       16
       14
        
               """

     

       17
       15
        
               topic = alert.severity.value

     

       18
       18
       -
               

     

       16
       16
       +
       

     

       19
       17
        
               # Severity emoji mapping

     

       20
       20
       -
               severity_emoji = {

     

       21
       21
       -
                   "critical": "🔴",

     

       22
       22
       -
                   "warning": "⚠️", 

     

       23
       23
       -
                   "clear": "✅"

     

       24
       24
       -
               }

     

       25
       25
       -
               

     

       18
       18
       +
               severity_emoji = {"critical": "🔴", "warning": "⚠️", "clear": "✅"}

     

       19
       19
       +
       

     

       26
       20
        
               emoji = severity_emoji.get(alert.severity.value, "📊")

     

       27
       27
       -
               

     

       21
       21
       +
       

     

       28
       22
        
               message = f"""{emoji} **{alert.alert}**

     

       29
       23
        
       

     

       30
       24
        
       **Space:** {alert.space}

     

       31
       25
        
       **Chart:** {alert.chart}

     

       32
       26
        
       **Context:** {alert.context}

     

       33
       27
        
       **Severity:** {alert.severity.value.title()}

     

       34
       34
       -
       **Time:** {alert.date.strftime('%Y-%m-%d %H:%M:%S UTC')}

     

       28
       28
       +
       **Time:** {alert.date.strftime("%Y-%m-%d %H:%M:%S UTC")}

     

       35
       29
        
       

     

       36
       30
        
       **Details:** {alert.info}

     

       37
       31
        
       

     

       38
       32
        
       **Summary:** {alert.message}

     

       39
       33
        
       

     

       40
       34
        
       [View Alert]({alert.alert_url})"""

     

       41
       41
       -
               

     

       35
       35
       +
       

     

       42
       36
        
               return topic, message

     

       43
       37
        
       

     

       44
       44
       -
           def format_reachability(self, notification: ReachabilityNotification) -> tuple[str, str]:

     

       38
       38
       +
           def format_reachability(

     

       39
       39
       +
               self, notification: ReachabilityNotification

     

       40
       40
       +
           ) -> tuple[str, str]:

     

       45
       41
        
               """Format reachability notification for Zulip.

     

       46
       46
       -
               

     

       42
       42
       +
       

     

       47
       43
        
               Returns:

     

       48
       44
        
                   Tuple of (topic, message_content)

     

       49
       45
        
               """

     

       50
       46
        
               topic = "reachability"

     

       51
       51
       -
               

     

       47
       47
       +
       

     

       52
       48
        
               status_emoji = "✅" if notification.status.reachable else "❌"

     

       53
       49
        
               severity_emoji = "🔴" if notification.severity.value == "critical" else "ℹ️"

     

       54
       54
       -
               

     

       50
       50
       +
       

     

       55
       51
        
               message = f"""{severity_emoji} **Host {notification.status.text.title()}**

     

       56
       52
        
       

     

       57
       53
        
       **Host:** {notification.host}

     
···

       61
       57
        
       **Summary:** {notification.message}

     

       62
       58
        
       

     

       63
       59
        
       [View Host]({notification.url})"""

     

       64
       64
       -
               

     

       60
       60
       +
       

     

       61
       61
       +
               return topic, message

     

       62
       62
       +
       

     

       63
       63
       +
           def format_test(self, notification: TestNotification) -> tuple[str, str]:

     

       64
       64
       +
               """Format test notification for Zulip.

     

       65
       65
       +
       

     

       66
       66
       +
               Returns:

     

       67
       67
       +
                   Tuple of (topic, message_content)

     

       68
       68
       +
               """

     

       69
       69
       +
               topic = "test"

     

       70
       70
       +
       

     

       71
       71
       +
               message = f"""🧪 **Netdata Webhook Test**

     

       72
       72
       +
       

     

       73
       73
       +
       {notification.message}

     

       74
       74
       +
       

     

       75
       75
       +
       Your webhook integration is working correctly! ✅"""

     

       76
       76
       +
       

     

       65
       77
        
               return topic, message

     

       66
       78
        
       

     

       67
       67
       -
           def format_notification(self, notification: Union[AlertNotification, ReachabilityNotification]) -> tuple[str, str]:

     

       79
       79
       +
           def format_notification(

     

       80
       80
       +
               self,

     

       81
       81
       +
               notification: (AlertNotification | ReachabilityNotification | TestNotification),

     

       82
       82
       +
           ) -> tuple[str, str]:

     

       68
       83
        
               """Format any notification type for Zulip.

     

       69
       69
       -
               

     

       84
       84
       +
       

     

       70
       85
        
               Returns:

     

       71
       86
        
                   Tuple of (topic, message_content)

     

       72
       87
        
               """

     
···

       74
       89
        
                   return self.format_alert(notification)

     

       75
       90
        
               elif isinstance(notification, ReachabilityNotification):

     

       76
       91
        
                   return self.format_reachability(notification)

     

       92
       92
       +
               elif isinstance(notification, TestNotification):

     

       93
       93
       +
                   return self.format_test(notification)

     

       77
       94
        
               else:

     

       78
       78
       -
                   raise ValueError(f"Unknown notification type: {type(notification)}")
     

       95
       95
       +
                   raise ValueError(f"Unknown notification type: {type(notification)}")

+42 -34

netdata_zulip_bot/main.py

···

       2
       2
        
       

     

       3
       3
        
       import argparse

     

       4
       4
        
       import sys

     

       5
       5
       -
       from pathlib import Path

     

       6
       5
        
       

     

       7
       6
        
       import structlog

     

       8
       7
        
       

     

       9
       8
        
       from .config import load_config, load_zuliprc_config

     

       10
       10
       -
       from .models import ServerConfig

     

       11
       9
        
       from .server import NetdataWebhookServer

     

       12
       10
        
       

     

       13
       11
        
       

     
···

       23
       21
        
                   structlog.processors.StackInfoRenderer(),

     

       24
       22
        
                   structlog.processors.format_exc_info,

     

       25
       23
        
                   structlog.processors.UnicodeDecoder(),

     

       26
       26
       -
                   structlog.processors.JSONRenderer()

     

       24
       24
       +
                   structlog.processors.JSONRenderer(),

     

       27
       25
        
               ],

     

       28
       26
        
               context_class=dict,

     

       29
       27
        
               logger_factory=structlog.stdlib.LoggerFactory(),

     
···

       34
       32
        
       

     

       35
       33
        
       def create_sample_configs():

     

       36
       34
        
           """Create sample configuration files."""

     

       37
       37
       -
           

     

       35
       35
       +
       

     

       38
       36
        
           # Sample .env file

     

       39
       39
       -
           env_content = """# Zulip Configuration

     

       40
       40
       -
       ZULIP_SITE=https://yourorg.zulipchat.com

     

       41
       41
       -
       ZULIP_EMAIL=netdata-bot@yourorg.zulipchat.com

     

       42
       42
       -
       ZULIP_API_KEY=your-api-key-here

     

       43
       43
       -
       ZULIP_STREAM=netdata-alerts

     

       44
       44
       -
       

     

       45
       45
       -
       # Server Configuration

     

       37
       37
       +
           env_content = """# Server Configuration (HTTP only, TLS handled by reverse proxy)

     

       46
       38
        
       SERVER_HOST=0.0.0.0

     

       47
       47
       -
       SERVER_PORT=8443

     

       48
       48
       -
       SERVER_DOMAIN=your-domain.com

     

       49
       49
       -
       SERVER_CERT_PATH=/etc/letsencrypt/live

     

       50
       50
       -
       SERVER_ENABLE_MTLS=true

     

       51
       51
       -
       SERVER_CLIENT_CA_PATH=/path/to/netdata-client-ca.pem

     

       39
       39
       +
       SERVER_PORT=8080

     

       40
       40
       +
       

     

       41
       41
       +
       # Netdata webhook challenge secret (required for webhook verification)

     

       42
       42
       +
       SERVER_CHALLENGE_SECRET=your-challenge-secret-here

     

       43
       43
       +
       

     

       44
       44
       +
       # Optional: Override Zulip stream (default: netdata-alerts)

     

       45
       45
       +
       # ZULIP_STREAM=custom-alerts-stream

     

       52
       46
        
       """

     

       53
       53
       -
           

     

       54
       54
       -
           with open(".env.sample", 'w') as f:

     

       47
       47
       +
       

     

       48
       48
       +
           with open(".env.sample", "w") as f:

     

       55
       49
        
               f.write(env_content)

     

       56
       56
       -
           

     

       50
       50
       +
       

     

       57
       51
        
           # Sample zuliprc file

     

       58
       52
        
           zuliprc_content = """[api]

     

       59
       53
        
       site=https://yourorg.zulipchat.com

     
···

       61
       55
        
       key=your-api-key-here

     

       62
       56
        
       stream=netdata-alerts

     

       63
       57
        
       """

     

       64
       64
       -
           

     

       65
       65
       -
           with open(".zuliprc.sample", 'w') as f:

     

       58
       58
       +
       

     

       59
       59
       +
           with open(".zuliprc.sample", "w") as f:

     

       66
       60
        
               f.write(zuliprc_content)

     

       67
       67
       -
           

     

       61
       61
       +
       

     

       68
       62
        
           print("Created sample configuration files:")

     

       69
       63
        
           print("  - .env.sample")

     

       70
       64
        
           print("  - .zuliprc.sample")

     
···

       77
       71
        
       def main():

     

       78
       72
        
           """Main entry point."""

     

       79
       73
        
           parser = argparse.ArgumentParser(

     

       80
       80
       -
               description="Netdata Zulip Bot - Webhook service for Netdata Cloud notifications"

     

       74
       74
       +
               description=(

     

       75
       75
       +
                   "Netdata Zulip Bot - Webhook service for Netdata Cloud notifications"

     

       76
       76
       +
               )

     

       81
       77
        
           )

     

       82
       78
        
           parser.add_argument(

     

       83
       83
       -
               "--zuliprc",

     

       84
       84
       -
               help="Path to zuliprc configuration file (default: ~/.zuliprc)"

     

       79
       79
       +
               "--zuliprc", help="Path to zuliprc configuration file (default: ~/.zuliprc)"

     

       85
       80
        
           )

     

       86
       81
        
           parser.add_argument(

     

       87
       82
        
               "--create-config",

     

       88
       83
        
               action="store_true",

     

       89
       89
       -
               help="Create sample configuration files and exit"

     

       84
       84
       +
               help="Create sample configuration files and exit",

     

       90
       85
        
           )

     

       91
       86
        
           parser.add_argument(

     

       92
       87
        
               "--env-config",

     

       93
       88
        
               action="store_true",

     

       94
       94
       -
               help="Use environment variables for configuration instead of zuliprc"

     

       89
       89
       +
               help="Use environment variables for configuration instead of zuliprc",

     

       95
       90
        
           )

     

       96
       96
       -
           

     

       91
       91
       +
       

     

       97
       92
        
           args = parser.parse_args()

     

       98
       98
       -
           

     

       93
       93
       +
       

     

       99
       94
        
           setup_logging()

     

       100
       95
        
           logger = structlog.get_logger()

     

       101
       101
       -
           

     

       96
       96
       +
       

     

       102
       97
        
           if args.create_config:

     

       103
       98
        
               create_sample_configs()

     

       104
       99
        
               return

     

       105
       105
       -
           

     

       100
       100
       +
       

     

       106
       101
        
           try:

     

       107
       102
        
               # Load configuration

     

       108
       103
        
               if args.env_config:

     

       109
       104
        
                   zulip_config, server_config = load_config()

     

       105
       105
       +
                   # Validate that required Zulip fields are provided via environment

     

       106
       106
       +
                   if not all([zulip_config.site, zulip_config.email, zulip_config.api_key]):

     

       107
       107
       +
                       missing = []

     

       108
       108
       +
                       if not zulip_config.site:

     

       109
       109
       +
                           missing.append("ZULIP_SITE")

     

       110
       110
       +
                       if not zulip_config.email:

     

       111
       111
       +
                           missing.append("ZULIP_EMAIL")

     

       112
       112
       +
                       if not zulip_config.api_key:

     

       113
       113
       +
                           missing.append("ZULIP_API_KEY")

     

       114
       114
       +
                       raise ValueError(

     

       115
       115
       +
                           f"When using --env-config, these environment variables are "

     

       116
       116
       +
                           f"required: {', '.join(missing)}"

     

       117
       117
       +
                       )

     

       110
       118
        
               else:

     

       111
       119
        
                   zulip_config = load_zuliprc_config(args.zuliprc)

     

       112
       120
        
                   # Still need server config from environment

     

       113
       121
        
                   _, server_config = load_config()

     

       114
       114
       -
               

     

       122
       122
       +
       

     

       115
       123
        
               # Create and start the webhook server

     

       116
       124
        
               server = NetdataWebhookServer(zulip_config, server_config)

     

       117
       125
        
               server.run()

     

       118
       118
       -
               

     

       126
       126
       +
       

     

       119
       127
        
           except KeyboardInterrupt:

     

       120
       128
        
               logger.info("Shutting down webhook server")

     

       121
       129
        
           except Exception as e:

     
···

       124
       132
        
       

     

       125
       133
        
       

     

       126
       134
        
       if __name__ == "__main__":

     

       127
       127
       -
           main()
     

       135
       135
       +
           main()

+41 -20

netdata_zulip_bot/models.py

···

       2
       2
        
       

     

       3
       3
        
       from datetime import datetime

     

       4
       4
        
       from enum import Enum

     

       5
       5
       -
       from typing import Optional, Union

     

       6
       5
        
       

     

       7
       7
       -
       from pydantic import BaseModel, Field, field_validator, ConfigDict

     

       6
       6
       +
       from pydantic import BaseModel, ConfigDict, Field, field_validator

     

       8
       7
        
       

     

       9
       8
        
       

     

       10
       9
        
       class AlertSeverity(str, Enum):

     

       11
       10
        
           """Alert severity levels."""

     

       11
       11
       +
       

     

       12
       12
        
           WARNING = "warning"

     

       13
       13
        
           CRITICAL = "critical"

     

       14
       14
        
           CLEAR = "clear"

     
···

       16
       16
        
       

     

       17
       17
        
       class ReachabilitySeverity(str, Enum):

     

       18
       18
        
           """Reachability severity levels."""

     

       19
       19
       +
       

     

       19
       20
        
           INFO = "info"

     

       20
       21
        
           CRITICAL = "critical"

     

       21
       22
        
       

     

       22
       23
        
       

     

       23
       24
        
       class ReachabilityStatus(BaseModel):

     

       24
       25
        
           """Reachability status information."""

     

       26
       26
       +
       

     

       25
       27
        
           reachable: bool

     

       26
       28
        
           text: str  # "reachable" or "unreachable"

     

       27
       29
        
       

     

       28
       30
        
       

     

       29
       31
        
       class AlertNotification(BaseModel):

     

       30
       32
        
           """Alert notification payload from Netdata Cloud."""

     

       33
       33
       +
       

     

       31
       34
        
           message: str

     

       32
       35
        
           alert: str

     

       33
       36
        
           info: str

     
···

       37
       40
        
           severity: AlertSeverity

     

       38
       41
        
           date: datetime

     

       39
       42
        
           alert_url: str

     

       43
       43
       +
           # Additional fields from full schema

     

       44
       44
       +
           Rooms: dict | None = None

     

       45
       45
       +
           family: str | None = None

     

       46
       46
       +
           class_: str | None = Field(None, alias="class")  # 'class' is a Python keyword

     

       47
       47
       +
           duration: str | None = None

     

       48
       48
       +
           additional_active_critical_alerts: int | None = None

     

       49
       49
       +
           additional_active_warning_alerts: int | None = None

     

       40
       50
        
       

     

       41
       41
       -
           @field_validator('date', mode='before')

     

       51
       51
       +
           @field_validator("date", mode="before")

     

       42
       52
        
           @classmethod

     

       43
       53
        
           def parse_date(cls, v):

     

       44
       54
        
               if isinstance(v, str):

     

       45
       45
       -
                   return datetime.fromisoformat(v.replace('Z', '+00:00'))

     

       55
       55
       +
                   return datetime.fromisoformat(v.replace("Z", "+00:00"))

     

       46
       56
        
               return v

     

       47
       57
        
       

     

       48
       58
        
       

     

       49
       59
        
       class ReachabilityNotification(BaseModel):

     

       50
       60
        
           """Reachability notification payload from Netdata Cloud."""

     

       61
       61
       +
       

     

       51
       62
        
           message: str

     

       52
       63
        
           url: str

     

       53
       64
        
           host: str

     
···

       55
       66
        
           status: ReachabilityStatus

     

       56
       67
        
       

     

       57
       68
        
       

     

       69
       69
       +
       class TestNotification(BaseModel):

     

       70
       70
       +
           """Test notification payload from Netdata Cloud."""

     

       71
       71
       +
       

     

       72
       72
       +
           message: str

     

       73
       73
       +
       

     

       74
       74
       +
       

     

       58
       75
        
       class WebhookPayload(BaseModel):

     

       59
       76
        
           """Union type for webhook payloads."""

     

       60
       60
       -
           

     

       77
       77
       +
       

     

       61
       78
        
           @classmethod

     

       62
       62
       -
           def parse(cls, data: dict) -> Union[AlertNotification, ReachabilityNotification]:

     

       79
       79
       +
           def parse(

     

       80
       80
       +
               cls, data: dict

     

       81
       81
       +
           ) -> AlertNotification | ReachabilityNotification | TestNotification:

     

       63
       82
        
               """Parse webhook payload and determine notification type."""

     

       64
       64
       -
               if 'alert' in data and 'chart' in data:

     

       83
       83
       +
               if "alert" in data and "chart" in data:

     

       65
       84
        
                   return AlertNotification(**data)

     

       66
       66
       -
               elif 'status' in data and 'host' in data:

     

       85
       85
       +
               elif "status" in data and "host" in data:

     

       67
       86
        
                   return ReachabilityNotification(**data)

     

       87
       87
       +
               elif len(data) == 1 and "message" in data:

     

       88
       88
       +
                   # Test notification - only has a message field

     

       89
       89
       +
                   return TestNotification(**data)

     

       68
       90
        
               else:

     

       69
       91
        
                   raise ValueError(f"Unknown notification type: {data}")

     

       70
       92
        
       

     

       71
       93
        
       

     

       72
       94
        
       class ZulipConfig(BaseModel):

     

       73
       95
        
           """Zulip bot configuration."""

     

       74
       74
       -
           site: str

     

       75
       75
       -
           email: str

     

       76
       76
       -
           api_key: str

     

       77
       77
       -
           stream: str

     

       78
       78
       -
           

     

       96
       96
       +
       

     

       97
       97
       +
           site: str | None = None

     

       98
       98
       +
           email: str | None = None

     

       99
       99
       +
           api_key: str | None = None

     

       100
       100
       +
           stream: str = "netdata-alerts"

     

       101
       101
       +
       

     

       79
       102
        
           model_config = ConfigDict(env_prefix="ZULIP_")

     

       80
       103
        
       

     

       81
       104
        
       

     

       82
       105
        
       class ServerConfig(BaseModel):

     

       83
       106
        
           """Server configuration."""

     

       107
       107
       +
       

     

       84
       108
        
           host: str = "0.0.0.0"

     

       85
       85
       -
           port: int = 8443

     

       86
       86
       -
           domain: str  # Required for Let's Encrypt

     

       87
       87
       -
           cert_path: str = "/etc/letsencrypt/live"

     

       88
       88
       -
           enable_mtls: bool = True

     

       89
       89
       -
           client_ca_path: Optional[str] = None

     

       90
       90
       -
           

     

       91
       91
       -
           model_config = ConfigDict(env_prefix="SERVER_")
     

       109
       109
       +
           port: int = 8080  # Default HTTP port

     

       110
       110
       +
           challenge_secret: str | None = None  # Netdata webhook challenge secret

     

       111
       111
       +
       

     

       112
       112
       +
           model_config = ConfigDict(env_prefix="SERVER_")

+72 -78

netdata_zulip_bot/server.py

···

       1
       1
        
       """FastAPI webhook server for receiving Netdata notifications."""

     

       2
       2
        
       

     

       3
       3
       -
       import ssl

     

       4
       4
       -
       from pathlib import Path

     

       5
       5
       -
       from typing import Dict, Any

     

       3
       3
       +
       import base64

     

       4
       4
       +
       import hashlib

     

       5
       5
       +
       import hmac

     

       6
       6
        
       

     

       7
       7
        
       import structlog

     

       8
       8
        
       import uvicorn

     

       9
       9
       -
       from fastapi import FastAPI, HTTPException, Request, status

     

       10
       10
       -
       from fastapi.responses import JSONResponse

     

       9
       9
       +
       from fastapi import FastAPI, HTTPException, Query, Request, status

     

       11
       10
        
       

     

       12
       11
        
       from .formatter import ZulipMessageFormatter

     

       13
       13
       -
       from .models import WebhookPayload, ZulipConfig, ServerConfig

     

       12
       12
       +
       from .models import ServerConfig, WebhookPayload, ZulipConfig

     

       14
       13
        
       from .zulip_client import ZulipNotifier

     

       15
       14
        
       

     

       16
       15
        
       logger = structlog.get_logger()

     
···

       18
       17
        
       

     

       19
       18
        
       class NetdataWebhookServer:

     

       20
       19
        
           """FastAPI server for handling Netdata Cloud webhooks."""

     

       21
       21
       -
           

     

       20
       20
       +
       

     

       22
       21
        
           def __init__(self, zulip_config: ZulipConfig, server_config: ServerConfig):

     

       23
       22
        
               """Initialize the webhook server."""

     

       24
       23
        
               self.app = FastAPI(

     

       25
       24
        
                   title="Netdata Zulip Bot",

     

       26
       25
        
                   description="Webhook service for Netdata Cloud notifications",

     

       27
       27
       -
                   version="0.1.0"

     

       26
       26
       +
                   version="0.1.0",

     

       28
       27
        
               )

     

       29
       28
        
               self.zulip_config = zulip_config

     

       30
       29
        
               self.server_config = server_config

     

       31
       30
        
               self.formatter = ZulipMessageFormatter()

     

       32
       32
       -
               

     

       31
       31
       +
       

     

       33
       32
        
               # Initialize Zulip client

     

       34
       33
        
               try:

     

       35
       34
        
                   self.zulip_notifier = ZulipNotifier(zulip_config)

     

       36
       35
        
               except Exception as e:

     

       37
       36
        
                   logger.error("Failed to initialize Zulip client", error=str(e))

     

       38
       37
        
                   raise

     

       39
       39
       -
                   

     

       38
       38
       +
       

     

       40
       39
        
               self._setup_routes()

     

       41
       40
        
               self._setup_middleware()

     

       42
       42
       -
           

     

       41
       41
       +
       

     

       43
       42
        
           def _setup_routes(self):

     

       44
       43
        
               """Setup FastAPI routes."""

     

       45
       45
       -
               

     

       44
       44
       +
       

     

       46
       45
        
               @self.app.get("/health")

     

       47
       46
        
               async def health_check():

     

       48
       47
        
                   """Health check endpoint."""

     

       49
       48
        
                   return {"status": "healthy", "service": "netdata-zulip-bot"}

     

       50
       50
       -
               

     

       49
       49
       +
       

     

       50
       50
       +
               @self.app.get("/webhook/netdata")

     

       51
       51
       +
               async def netdata_webhook_challenge(crc_token: str = Query(...)):

     

       52
       52
       +
                   """Handle Netdata Cloud webhook challenge for verification."""

     

       53
       53
       +
                   if not self.server_config.challenge_secret:

     

       54
       54
       +
                       logger.error("Challenge secret not configured")

     

       55
       55
       +
                       raise HTTPException(

     

       56
       56
       +
                           status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

     

       57
       57
       +
                           detail="Challenge secret not configured",

     

       58
       58
       +
                       )

     

       59
       59
       +
       

     

       60
       60
       +
                   try:

     

       61
       61
       +
                       # Create HMAC SHA-256 hash from crc_token and challenge secret

     

       62
       62
       +
                       token_bytes = crc_token.encode("ascii")

     

       63
       63
       +
                       secret_bytes = self.server_config.challenge_secret.encode("utf-8")

     

       64
       64
       +
       

     

       65
       65
       +
                       sha256_hash = hmac.new(

     

       66
       66
       +
                           secret_bytes, msg=token_bytes, digestmod=hashlib.sha256

     

       67
       67
       +
                       ).digest()

     

       68
       68
       +
       

     

       69
       69
       +
                       # Create response with base64 encoded hash

     

       70
       70
       +
                       response_token = "sha256=" + base64.b64encode(sha256_hash).decode(

     

       71
       71
       +
                           "ascii"

     

       72
       72
       +
                       )

     

       73
       73
       +
       

     

       74
       74
       +
                       logger.info(

     

       75
       75
       +
                           "Responding to Netdata challenge", crc_token=crc_token[:16] + "..."

     

       76
       76
       +
                       )

     

       77
       77
       +
                       return {"response_token": response_token}

     

       78
       78
       +
       

     

       79
       79
       +
                   except Exception as e:

     

       80
       80
       +
                       logger.error("Failed to process challenge", error=str(e))

     

       81
       81
       +
                       raise HTTPException(

     

       82
       82
       +
                           status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

     

       83
       83
       +
                           detail="Failed to process challenge",

     

       84
       84
       +
                       )

     

       85
       85
       +
       

     

       51
       86
        
               @self.app.post("/webhook/netdata")

     

       52
       87
        
               async def netdata_webhook(request: Request):

     

       53
       88
        
                   """Handle Netdata Cloud webhook notifications."""

     
···

       55
       90
        
                       # Get raw JSON data

     

       56
       91
        
                       body = await request.json()

     

       57
       92
        
                       logger.info("Received webhook", payload_keys=list(body.keys()))

     

       58
       58
       -
                       

     

       93
       93
       +
       

     

       59
       94
        
                       # Parse and validate the payload

     

       60
       95
        
                       notification = WebhookPayload.parse(body)

     

       61
       96
        
                       logger.info("Parsed notification", type=type(notification).__name__)

     

       62
       62
       -
                       

     

       97
       97
       +
       

     

       63
       98
        
                       # Format message for Zulip

     

       64
       99
        
                       topic, content = self.formatter.format_notification(notification)

     

       65
       100
        
                       logger.info("Formatted message", topic=topic)

     

       66
       66
       -
                       

     

       101
       101
       +
       

     

       67
       102
        
                       # Send to Zulip

     

       68
       103
        
                       success = self.zulip_notifier.send_message(topic, content)

     

       69
       69
       -
                       

     

       104
       104
       +
       

     

       70
       105
        
                       if success:

     

       71
       71
       -
                           return {"status": "success", "message": "Notification sent to Zulip"}

     

       106
       106
       +
                           return {

     

       107
       107
       +
                               "status": "success",

     

       108
       108
       +
                               "message": "Notification sent to Zulip",

     

       109
       109
       +
                           }

     

       72
       110
        
                       else:

     

       73
       111
        
                           raise HTTPException(

     

       74
       112
        
                               status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

     

       75
       75
       -
                               detail="Failed to send notification to Zulip"

     

       113
       113
       +
                               detail="Failed to send notification to Zulip",

     

       76
       114
        
                           )

     

       77
       77
       -
                           

     

       115
       115
       +
       

     

       78
       116
        
                   except ValueError as e:

     

       79
       117
        
                       logger.error("Invalid webhook payload", error=str(e))

     

       80
       118
        
                       raise HTTPException(

     

       81
       119
        
                           status_code=status.HTTP_400_BAD_REQUEST,

     

       82
       82
       -
                           detail=f"Invalid payload format: {str(e)}"

     

       120
       120
       +
                           detail=f"Invalid payload format: {str(e)}",

     

       83
       121
        
                       )

     

       84
       122
        
                   except Exception as e:

     

       85
       123
        
                       logger.error("Webhook processing failed", error=str(e))

     

       86
       124
        
                       raise HTTPException(

     

       87
       125
        
                           status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

     

       88
       88
       -
                           detail="Internal server error"

     

       126
       126
       +
                           detail="Internal server error",

     

       89
       127
        
                       )

     

       90
       90
       -
           

     

       128
       128
       +
       

     

       91
       129
        
           def _setup_middleware(self):

     

       92
       130
        
               """Setup middleware for logging and error handling."""

     

       93
       93
       -
               

     

       131
       131
       +
       

     

       94
       132
        
               @self.app.middleware("http")

     

       95
       133
        
               async def log_requests(request: Request, call_next):

     

       96
       134
        
                   """Log all requests."""

     
···

       99
       137
        
                       "Request received",

     

       100
       138
        
                       method=request.method,

     

       101
       139
        
                       url=str(request.url),

     

       102
       102
       -
                       client=client_host

     

       140
       140
       +
                       client=client_host,

     

       103
       141
        
                   )

     

       104
       104
       -
                   

     

       142
       142
       +
       

     

       105
       143
        
                   try:

     

       106
       144
        
                       response = await call_next(request)

     

       107
       145
        
                       logger.info(

     

       108
       146
        
                           "Request completed",

     

       109
       147
        
                           method=request.method,

     

       110
       148
        
                           url=str(request.url),

     

       111
       111
       -
                           status_code=response.status_code

     

       149
       149
       +
                           status_code=response.status_code,

     

       112
       150
        
                       )

     

       113
       151
        
                       return response

     

       114
       152
        
                   except Exception as e:

     
···

       116
       154
        
                           "Request failed",

     

       117
       155
        
                           method=request.method,

     

       118
       156
        
                           url=str(request.url),

     

       119
       119
       -
                           error=str(e)

     

       157
       157
       +
                           error=str(e),

     

       120
       158
        
                       )

     

       121
       159
        
                       raise

     

       122
       122
       -
           

     

       123
       123
       -
           def get_ssl_context(self) -> ssl.SSLContext:

     

       124
       124
       -
               """Create SSL context for HTTPS and mutual TLS."""

     

       125
       125
       -
               context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)

     

       126
       126
       -
               

     

       127
       127
       -
               # Load server certificate and key

     

       128
       128
       -
               cert_path = Path(self.server_config.cert_path) / self.server_config.domain

     

       129
       129
       -
               cert_file = cert_path / "fullchain.pem"

     

       130
       130
       -
               key_file = cert_path / "privkey.pem"

     

       131
       131
       -
               

     

       132
       132
       -
               if not cert_file.exists() or not key_file.exists():

     

       133
       133
       -
                   logger.error(

     

       134
       134
       -
                       "SSL certificate files not found",

     

       135
       135
       -
                       cert_file=str(cert_file),

     

       136
       136
       -
                       key_file=str(key_file)

     

       137
       137
       -
                   )

     

       138
       138
       -
                   raise FileNotFoundError(f"SSL certificate files not found at {cert_path}")

     

       139
       139
       -
               

     

       140
       140
       -
               context.load_cert_chain(str(cert_file), str(key_file))

     

       141
       141
       -
               

     

       142
       142
       -
               # Configure mutual TLS if enabled

     

       143
       143
       -
               if self.server_config.enable_mtls:

     

       144
       144
       -
                   if self.server_config.client_ca_path:

     

       145
       145
       -
                       ca_path = Path(self.server_config.client_ca_path)

     

       146
       146
       -
                       if ca_path.exists():

     

       147
       147
       -
                           context.load_verify_locations(str(ca_path))

     

       148
       148
       -
                           context.verify_mode = ssl.CERT_REQUIRED

     

       149
       149
       -
                           logger.info("Mutual TLS enabled", ca_path=str(ca_path))

     

       150
       150
       -
                       else:

     

       151
       151
       -
                           logger.warning("Client CA file not found, disabling mutual TLS", ca_path=str(ca_path))

     

       152
       152
       -
                           context.verify_mode = ssl.CERT_NONE

     

       153
       153
       -
                   else:

     

       154
       154
       -
                       logger.warning("No client CA path configured, disabling mutual TLS")

     

       155
       155
       -
                       context.verify_mode = ssl.CERT_NONE

     

       156
       156
       -
               else:

     

       157
       157
       -
                   context.verify_mode = ssl.CERT_NONE

     

       158
       158
       -
                   logger.info("Mutual TLS disabled")

     

       159
       159
       -
               

     

       160
       160
       -
               return context

     

       161
       161
       -
           

     

       160
       160
       +
       

     

       162
       161
        
           def run(self):

     

       163
       163
       -
               """Run the webhook server with HTTPS and optional mutual TLS."""

     

       162
       162
       +
               """Run the webhook server (HTTP only, TLS handled by reverse proxy)."""

     

       164
       163
        
               try:

     

       165
       165
       -
                   ssl_context = self.get_ssl_context()

     

       166
       166
       -
                   

     

       167
       164
        
                   logger.info(

     

       168
       168
       -
                       "Starting Netdata Zulip webhook server",

     

       165
       165
       +
                       "Starting Netdata Zulip webhook server (HTTP)",

     

       169
       166
        
                       host=self.server_config.host,

     

       170
       167
        
                       port=self.server_config.port,

     

       171
       171
       -
                       domain=self.server_config.domain,

     

       172
       172
       -
                       mtls_enabled=self.server_config.enable_mtls

     

       173
       168
        
                   )

     

       174
       174
       -
                   

     

       169
       169
       +
       

     

       175
       170
        
                   uvicorn.run(

     

       176
       171
        
                       self.app,

     

       177
       172
        
                       host=self.server_config.host,

     

       178
       173
        
                       port=self.server_config.port,

     

       179
       179
       -
                       ssl_context=ssl_context,

     

       180
       174
        
                       access_log=False,  # We handle logging in middleware

     

       181
       175
        
                   )

     

       182
       182
       -
                   

     

       176
       176
       +
       

     

       183
       177
        
               except Exception as e:

     

       184
       178
        
                   logger.error("Failed to start server", error=str(e))

     

       185
       185
       -
                   raise
     

       179
       179
       +
                   raise

+22 -20

netdata_zulip_bot/zulip_client.py

···

       10
       10
        
       

     

       11
       11
        
       class ZulipNotifier:

     

       12
       12
        
           """Handles sending notifications to Zulip."""

     

       13
       13
       -
           

     

       13
       13
       +
       

     

       14
       14
        
           def __init__(self, config: ZulipConfig):

     

       15
       15
        
               """Initialize Zulip client with configuration."""

     

       16
       16
        
               self.config = config

     
···

       19
       19
        
                   email=config.email,

     

       20
       20
        
                   api_key=config.api_key,

     

       21
       21
        
               )

     

       22
       22
       -
               

     

       22
       22
       +
       

     

       23
       23
        
               # Test connection

     

       24
       24
        
               try:

     

       25
       25
        
                   result = self.client.get_profile()

     

       26
       26
       -
                   if result['result'] != 'success':

     

       26
       26
       +
                   if result["result"] != "success":

     

       27
       27
        
                       raise ConnectionError(f"Failed to connect to Zulip: {result}")

     

       28
       28
       -
                   logger.info("Connected to Zulip", user=result['email'])

     

       28
       28
       +
                   logger.info("Connected to Zulip", user=result["email"])

     

       29
       29
        
               except Exception as e:

     

       30
       30
        
                   logger.error("Failed to initialize Zulip client", error=str(e))

     

       31
       31
        
                   raise

     

       32
       32
       -
           

     

       32
       32
       +
       

     

       33
       33
        
           def send_message(self, topic: str, content: str) -> bool:

     

       34
       34
        
               """Send a message to the configured Zulip stream.

     

       35
       35
       -
               

     

       35
       35
       +
       

     

       36
       36
        
               Args:

     

       37
       37
        
                   topic: The topic within the stream

     

       38
       38
        
                   content: The message content (markdown formatted)

     

       39
       39
       -
                   

     

       39
       39
       +
       

     

       40
       40
        
               Returns:

     

       41
       41
        
                   True if successful, False otherwise

     

       42
       42
        
               """

     

       43
       43
        
               try:

     

       44
       44
       -
                   result = self.client.send_message({

     

       45
       45
       -
                       "type": "stream",

     

       46
       46
       -
                       "to": self.config.stream,

     

       47
       47
       -
                       "topic": topic,

     

       48
       48
       -
                       "content": content,

     

       49
       49
       -
                   })

     

       50
       50
       -
                   

     

       51
       51
       -
                   if result['result'] == 'success':

     

       44
       44
       +
                   result = self.client.send_message(

     

       45
       45
       +
                       {

     

       46
       46
       +
                           "type": "stream",

     

       47
       47
       +
                           "to": self.config.stream,

     

       48
       48
       +
                           "topic": topic,

     

       49
       49
       +
                           "content": content,

     

       50
       50
       +
                       }

     

       51
       51
       +
                   )

     

       52
       52
       +
       

     

       53
       53
       +
                   if result["result"] == "success":

     

       52
       54
        
                       logger.info(

     

       53
       55
        
                           "Message sent to Zulip",

     

       54
       56
        
                           stream=self.config.stream,

     

       55
       57
        
                           topic=topic,

     

       56
       56
       -
                           message_id=result.get('id')

     

       58
       58
       +
                           message_id=result.get("id"),

     

       57
       59
        
                       )

     

       58
       60
        
                       return True

     

       59
       61
        
                   else:

     
···

       61
       63
        
                           "Failed to send message to Zulip",

     

       62
       64
        
                           stream=self.config.stream,

     

       63
       65
        
                           topic=topic,

     

       64
       64
       -
                           error=result.get('msg', 'Unknown error')

     

       66
       66
       +
                           error=result.get("msg", "Unknown error"),

     

       65
       67
        
                       )

     

       66
       68
        
                       return False

     

       67
       67
       -
                       

     

       69
       69
       +
       

     

       68
       70
        
               except Exception as e:

     

       69
       71
        
                   logger.error(

     

       70
       72
        
                       "Exception sending message to Zulip",

     

       71
       73
        
                       stream=self.config.stream,

     

       72
       74
        
                       topic=topic,

     

       73
       73
       -
                       error=str(e)

     

       75
       75
       +
                       error=str(e),

     

       74
       76
        
                   )

     

       75
       75
       -
                   return False
     

       77
       77
       +
                   return False

+1 -3

pyproject.toml

···

       3
       3
        
       version = "0.1.0"

     

       4
       4
        
       description = "Zulip bot for receiving Netdata Cloud webhook notifications"

     

       5
       5
        
       authors = [

     

       6
       6
       -
           {name = "Your Name", email = "your.email@example.com"}

     

       6
       6
       +
           {name = "Anil Madhavapeddy", email = "anil@recoil.org"}

     

       7
       7
        
       ]

     

       8
       8
        
       readme = "README.md"

     

       9
       9
        
       requires-python = ">=3.11"

     
···

       13
       13
        
           "zulip>=0.9.0",

     

       14
       14
        
           "pydantic>=2.5.0",

     

       15
       15
        
           "python-multipart>=0.0.6",

     

       16
       16
       -
           "certbot>=2.8.0",

     

       17
       17
       -
           "cryptography>=41.0.0",

     

       18
       16
        
           "python-dotenv>=1.0.0",

     

       19
       17
        
           "structlog>=23.2.0",

     

       20
       18
        
       ]

+1 -1

tests/__init__.py

···

       1
       1
       -
       """Tests for the Netdata Zulip Bot."""
     

       1
       1
       +
       """Tests for the Netdata Zulip Bot."""

+46 -49

tests/test_webhook.py

···

       1
       1
        
       """Tests for webhook functionality."""

     

       2
       2
        
       

     

       3
       3
       -
       import pytest

     

       4
       3
        
       from datetime import datetime

     

       5
       5
       -
       from unittest.mock import Mock, patch

     

       6
       4
        
       

     

       7
       7
       -
       from netdata_zulip_bot.models import AlertNotification, ReachabilityNotification, WebhookPayload

     

       5
       5
       +
       import pytest

     

       6
       6
       +
       

     

       8
       7
        
       from netdata_zulip_bot.formatter import ZulipMessageFormatter

     

       8
       8
       +
       from netdata_zulip_bot.models import (

     

       9
       9
       +
           AlertNotification,

     

       10
       10
       +
           ReachabilityNotification,

     

       11
       11
       +
           WebhookPayload,

     

       12
       12
       +
       )

     

       9
       13
        
       

     

       10
       14
        
       

     

       11
       15
        
       class TestWebhookPayload:

     

       12
       16
        
           """Test webhook payload parsing."""

     

       13
       13
       -
           

     

       17
       17
       +
       

     

       14
       18
        
           def test_parse_alert_notification(self):

     

       15
       19
        
               """Test parsing alert notification payload."""

     

       16
       20
        
               data = {

     
···

       22
       26
        
                   "space": "production",

     

       23
       27
        
                   "severity": "critical",

     

       24
       28
        
                   "date": "2024-01-15T14:30:00Z",

     

       25
       25
       -
                   "alert_url": "https://app.netdata.cloud/spaces/abc/alerts/123"

     

       29
       29
       +
                   "alert_url": "https://app.netdata.cloud/spaces/abc/alerts/123",

     

       26
       30
        
               }

     

       27
       27
       -
               

     

       31
       31
       +
       

     

       28
       32
        
               notification = WebhookPayload.parse(data)

     

       29
       33
        
               assert isinstance(notification, AlertNotification)

     

       30
       34
        
               assert notification.severity.value == "critical"

     

       31
       35
        
               assert notification.alert == "high_cpu_usage"

     

       32
       36
        
               assert isinstance(notification.date, datetime)

     

       33
       33
       -
           

     

       37
       37
       +
       

     

       34
       38
        
           def test_parse_reachability_notification(self):

     

       35
       39
        
               """Test parsing reachability notification payload."""

     

       36
       40
        
               data = {

     
···

       38
       42
        
                   "url": "https://app.netdata.cloud/hosts/web-server-01",

     

       39
       43
        
                   "host": "web-server-01",

     

       40
       44
        
                   "severity": "critical",

     

       41
       41
       -
                   "status": {

     

       42
       42
       -
                       "reachable": False,

     

       43
       43
       -
                       "text": "unreachable"

     

       44
       44
       -
                   }

     

       45
       45
       +
                   "status": {"reachable": False, "text": "unreachable"},

     

       45
       46
        
               }

     

       46
       46
       -
               

     

       47
       47
       +
       

     

       47
       48
        
               notification = WebhookPayload.parse(data)

     

       48
       49
        
               assert isinstance(notification, ReachabilityNotification)

     

       49
       50
        
               assert notification.severity.value == "critical"

     

       50
       51
        
               assert notification.host == "web-server-01"

     

       51
       52
        
               assert not notification.status.reachable

     

       52
       52
       -
           

     

       53
       53
       +
       

     

       53
       54
        
           def test_parse_unknown_payload_raises_error(self):

     

       54
       55
        
               """Test that unknown payload types raise ValueError."""

     

       55
       56
        
               data = {"unknown_field": "value"}

     

       56
       56
       -
               

     

       57
       57
       +
       

     

       57
       58
        
               with pytest.raises(ValueError, match="Unknown notification type"):

     

       58
       59
        
                   WebhookPayload.parse(data)

     

       59
       60
        
       

     

       60
       61
        
       

     

       61
       62
        
       class TestZulipMessageFormatter:

     

       62
       63
        
           """Test Zulip message formatting."""

     

       63
       63
       -
           

     

       64
       64
       +
       

     

       64
       65
        
           def setup_method(self):

     

       65
       66
        
               """Set up test fixtures."""

     

       66
       67
        
               self.formatter = ZulipMessageFormatter()

     

       67
       67
       -
           

     

       68
       68
       +
       

     

       68
       69
        
           def test_format_critical_alert(self):

     

       69
       70
        
               """Test formatting critical alert notification."""

     

       70
       71
        
               alert = AlertNotification(

     
···

       72
       73
        
                   alert="high_cpu_usage",

     

       73
       74
        
                   info="CPU usage exceeded 90% for 5 minutes",

     

       74
       75
        
                   chart="system.cpu",

     

       75
       75
       -
                   context="cpu.utilization", 

     

       76
       76
       +
                   context="cpu.utilization",

     

       76
       77
        
                   space="production",

     

       77
       78
        
                   severity="critical",

     

       78
       79
        
                   date=datetime(2024, 1, 15, 14, 30, 0),

     

       79
       79
       -
                   alert_url="https://app.netdata.cloud/spaces/abc/alerts/123"

     

       80
       80
       +
                   alert_url="https://app.netdata.cloud/spaces/abc/alerts/123",

     

       80
       81
        
               )

     

       81
       81
       -
               

     

       82
       82
       +
       

     

       82
       83
        
               topic, content = self.formatter.format_alert(alert)

     

       83
       83
       -
               

     

       84
       84
       +
       

     

       84
       85
        
               assert topic == "critical"

     

       85
       86
        
               assert "🔴" in content

     

       86
       87
        
               assert "**high_cpu_usage**" in content

     

       87
       88
        
               assert "production" in content

     

       88
       89
        
               assert "Critical" in content

     

       89
       90
        
               assert "2024-01-15 14:30:00 UTC" in content

     

       90
       90
       -
               assert "[View Alert](https://app.netdata.cloud/spaces/abc/alerts/123)" in content

     

       91
       91
       -
           

     

       91
       91
       +
               assert (

     

       92
       92
       +
                   "[View Alert](https://app.netdata.cloud/spaces/abc/alerts/123)" in content

     

       93
       93
       +
               )

     

       94
       94
       +
       

     

       92
       95
        
           def test_format_warning_alert(self):

     

       93
       96
        
               """Test formatting warning alert notification."""

     

       94
       97
        
               alert = AlertNotification(

     

       95
       98
        
                   message="Warning: High memory usage",

     

       96
       96
       -
                   alert="high_memory_usage", 

     

       99
       99
       +
                   alert="high_memory_usage",

     

       97
       100
        
                   info="Memory usage at 85%",

     

       98
       101
        
                   chart="system.ram",

     

       99
       102
        
                   context="memory.utilization",

     

       100
       103
        
                   space="staging",

     

       101
       104
        
                   severity="warning",

     

       102
       105
        
                   date=datetime(2024, 1, 15, 10, 15, 0),

     

       103
       103
       -
                   alert_url="https://app.netdata.cloud/spaces/def/alerts/456"

     

       106
       106
       +
                   alert_url="https://app.netdata.cloud/spaces/def/alerts/456",

     

       104
       107
        
               )

     

       105
       105
       -
               

     

       108
       108
       +
       

     

       106
       109
        
               topic, content = self.formatter.format_alert(alert)

     

       107
       107
       -
               

     

       110
       110
       +
       

     

       108
       111
        
               assert topic == "warning"

     

       109
       112
        
               assert "⚠️" in content

     

       110
       113
        
               assert "Warning" in content

     

       111
       111
       -
           

     

       114
       114
       +
       

     

       112
       115
        
           def test_format_clear_alert(self):

     

       113
       116
        
               """Test formatting clear alert notification."""

     

       114
       117
        
               alert = AlertNotification(

     

       115
       118
        
                   message="Alert cleared: CPU usage normal",

     

       116
       119
        
                   alert="high_cpu_usage",

     

       117
       120
        
                   info="CPU usage returned to normal levels",

     

       118
       118
       -
                   chart="system.cpu", 

     

       121
       121
       +
                   chart="system.cpu",

     

       119
       122
        
                   context="cpu.utilization",

     

       120
       123
        
                   space="production",

     

       121
       124
        
                   severity="clear",

     

       122
       125
        
                   date=datetime(2024, 1, 15, 15, 0, 0),

     

       123
       123
       -
                   alert_url="https://app.netdata.cloud/spaces/abc/alerts/123"

     

       126
       126
       +
                   alert_url="https://app.netdata.cloud/spaces/abc/alerts/123",

     

       124
       127
        
               )

     

       125
       125
       -
               

     

       128
       128
       +
       

     

       126
       129
        
               topic, content = self.formatter.format_alert(alert)

     

       127
       127
       -
               

     

       130
       130
       +
       

     

       128
       131
        
               assert topic == "clear"

     

       129
       132
        
               assert "✅" in content

     

       130
       133
        
               assert "Clear" in content

     

       131
       131
       -
           

     

       134
       134
       +
       

     

       132
       135
        
           def test_format_reachability_unreachable(self):

     

       133
       136
        
               """Test formatting unreachable host notification."""

     

       134
       137
        
               notification = ReachabilityNotification(

     
···

       136
       139
        
                   url="https://app.netdata.cloud/hosts/web-server-01",

     

       137
       140
        
                   host="web-server-01",

     

       138
       141
        
                   severity="critical",

     

       139
       139
       -
                   status={

     

       140
       140
       -
                       "reachable": False,

     

       141
       141
       -
                       "text": "unreachable"

     

       142
       142
       -
                   }

     

       142
       142
       +
                   status={"reachable": False, "text": "unreachable"},

     

       143
       143
        
               )

     

       144
       144
       -
               

     

       144
       144
       +
       

     

       145
       145
        
               topic, content = self.formatter.format_reachability(notification)

     

       146
       146
       -
               

     

       146
       146
       +
       

     

       147
       147
        
               assert topic == "reachability"

     

       148
       148
        
               assert "🔴" in content  # critical severity

     

       149
       149
        
               assert "❌" in content  # unreachable status

     

       150
       150
        
               assert "web-server-01" in content

     

       151
       151
        
               assert "Unreachable" in content

     

       152
       152
        
               assert "[View Host](https://app.netdata.cloud/hosts/web-server-01)" in content

     

       153
       153
       -
           

     

       153
       153
       +
       

     

       154
       154
        
           def test_format_reachability_reachable(self):

     

       155
       155
        
               """Test formatting reachable host notification."""

     

       156
       156
        
               notification = ReachabilityNotification(

     

       157
       157
        
                   message="Host web-server-01 is reachable again",

     

       158
       158
       -
                   url="https://app.netdata.cloud/hosts/web-server-01", 

     

       158
       158
       +
                   url="https://app.netdata.cloud/hosts/web-server-01",

     

       159
       159
        
                   host="web-server-01",

     

       160
       160
        
                   severity="info",

     

       161
       161
       -
                   status={

     

       162
       162
       -
                       "reachable": True,

     

       163
       163
       -
                       "text": "reachable"

     

       164
       164
       -
                   }

     

       161
       161
       +
                   status={"reachable": True, "text": "reachable"},

     

       165
       162
        
               )

     

       166
       166
       -
               

     

       163
       163
       +
       

     

       167
       164
        
               topic, content = self.formatter.format_reachability(notification)

     

       168
       168
       -
               

     

       165
       165
       +
       

     

       169
       166
        
               assert topic == "reachability"

     

       170
       170
       -
               assert "ℹ️" in content   # info severity

     

       171
       171
       -
               assert "✅" in content   # reachable status

     

       172
       172
       -
               assert "Reachable" in content
     

       167
       167
       +
               assert "ℹ️" in content  # info severity

     

       168
       168
       +
               assert "✅" in content  # reachable status

     

       169
       169
       +
               assert "Reachable" in content

-215

uv.lock

···

       3
       3
        
       requires-python = ">=3.11"

     

       4
       4
        
       

     

       5
       5
        
       [[package]]

     

       6
       6
       -
       name = "acme"

     

       7
       7
       -
       version = "4.2.0"

     

       8
       8
       -
       source = { registry = "https://pypi.org/simple" }

     

       9
       9
       -
       dependencies = [

     

       10
       10
       -
           { name = "cryptography" },

     

       11
       11
       -
           { name = "josepy" },

     

       12
       12
       -
           { name = "pyopenssl" },

     

       13
       13
       -
           { name = "pyrfc3339" },

     

       14
       14
       -
           { name = "requests" },

     

       15
       15
       -
       ]

     

       16
       16
       -
       sdist = { url = "https://files.pythonhosted.org/packages/48/df/d006c4920fd04b843c21698bd038968cb9caa3315608f55abde0f8e4ad6b/acme-4.2.0.tar.gz", hash = "sha256:0df68c0e1acb3824a2100013f8cd51bda2e1a56aa23447449d14c942959f0c41", size = 96820, upload-time = "2025-08-05T19:19:08.86Z" }

     

       17
       17
       -
       wheels = [

     

       18
       18
       -
           { url = "https://files.pythonhosted.org/packages/86/26/9ff889b5d762616bf92ecbeb1ab93faddfd7bf6068146340359e9a6beb43/acme-4.2.0-py3-none-any.whl", hash = "sha256:6292011bbfa5f966521b2fb9469982c24ff4c58e240985f14564ccf35372e79a", size = 101573, upload-time = "2025-08-05T19:18:45.266Z" },

     

       19
       19
       -
       ]

     

       20
       20
       -
       

     

       21
       21
       -
       [[package]]

     

       22
       6
        
       name = "annotated-types"

     

       23
       7
        
       version = "0.7.0"

     

       24
       8
        
       source = { registry = "https://pypi.org/simple" }

     
···

       70
       54
        
       ]

     

       71
       55
        
       

     

       72
       56
        
       [[package]]

     

       73
       73
       -
       name = "certbot"

     

       74
       74
       -
       version = "4.2.0"

     

       75
       75
       -
       source = { registry = "https://pypi.org/simple" }

     

       76
       76
       -
       dependencies = [

     

       77
       77
       -
           { name = "acme" },

     

       78
       78
       -
           { name = "configargparse" },

     

       79
       79
       -
           { name = "configobj" },

     

       80
       80
       -
           { name = "cryptography" },

     

       81
       81
       -
           { name = "distro" },

     

       82
       82
       -
           { name = "josepy" },

     

       83
       83
       -
           { name = "parsedatetime" },

     

       84
       84
       -
           { name = "pyrfc3339" },

     

       85
       85
       -
           { name = "pywin32", marker = "sys_platform == 'win32'" },

     

       86
       86
       -
       ]

     

       87
       87
       -
       sdist = { url = "https://files.pythonhosted.org/packages/f2/e3/199262bf00c9bd5dfccfe0a64c26c2fb132b92511bee416c3408a54b4cf1/certbot-4.2.0.tar.gz", hash = "sha256:fb1e56ca8a072bec49ac0c7b5390a29cbf68c2c05f712259a9b3491de041c27b", size = 442984, upload-time = "2025-08-05T19:19:22.495Z" }

     

       88
       88
       -
       wheels = [

     

       89
       89
       -
           { url = "https://files.pythonhosted.org/packages/fa/e4/5176fcd1195ffd358bb1129baa0f411da7eede3d47eb39e05062b5f22105/certbot-4.2.0-py3-none-any.whl", hash = "sha256:8fcca0c1a06df9ce39e89b7d13c70506e1372823e8b5993633d21adb77581950", size = 409215, upload-time = "2025-08-05T19:19:06.803Z" },

     

       90
       90
       -
       ]

     

       91
       91
       -
       

     

       92
       92
       -
       [[package]]

     

       93
       57
        
       name = "certifi"

     

       94
       58
        
       version = "2025.8.3"

     

       95
       59
        
       source = { registry = "https://pypi.org/simple" }

     
···

       99
       63
        
       ]

     

       100
       64
        
       

     

       101
       65
        
       [[package]]

     

       102
       102
       -
       name = "cffi"

     

       103
       103
       -
       version = "1.17.1"

     

       104
       104
       -
       source = { registry = "https://pypi.org/simple" }

     

       105
       105
       -
       dependencies = [

     

       106
       106
       -
           { name = "pycparser" },

     

       107
       107
       -
       ]

     

       108
       108
       -
       sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }

     

       109
       109
       -
       wheels = [

     

       110
       110
       -
           { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" },

     

       111
       111
       -
           { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" },

     

       112
       112
       -
           { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" },

     

       113
       113
       -
           { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" },

     

       114
       114
       -
           { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" },

     

       115
       115
       -
           { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" },

     

       116
       116
       -
           { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" },

     

       117
       117
       -
           { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" },

     

       118
       118
       -
           { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" },

     

       119
       119
       -
           { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" },

     

       120
       120
       -
           { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" },

     

       121
       121
       -
           { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" },

     

       122
       122
       -
           { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" },

     

       123
       123
       -
           { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" },

     

       124
       124
       -
           { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" },

     

       125
       125
       -
           { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" },

     

       126
       126
       -
           { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" },

     

       127
       127
       -
           { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" },

     

       128
       128
       -
           { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" },

     

       129
       129
       -
           { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" },

     

       130
       130
       -
           { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" },

     

       131
       131
       -
           { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },

     

       132
       132
       -
           { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },

     

       133
       133
       -
           { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" },

     

       134
       134
       -
           { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" },

     

       135
       135
       -
           { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" },

     

       136
       136
       -
           { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" },

     

       137
       137
       -
           { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" },

     

       138
       138
       -
           { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" },

     

       139
       139
       -
           { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" },

     

       140
       140
       -
           { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" },

     

       141
       141
       -
           { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" },

     

       142
       142
       -
           { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" },

     

       143
       143
       -
           { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" },

     

       144
       144
       -
       ]

     

       145
       145
       -
       

     

       146
       146
       -
       [[package]]

     

       147
       66
        
       name = "charset-normalizer"

     

       148
       67
        
       version = "3.4.3"

     

       149
       68
        
       source = { registry = "https://pypi.org/simple" }

     
···

       218
       137
        
       ]

     

       219
       138
        
       

     

       220
       139
        
       [[package]]

     

       221
       221
       -
       name = "configargparse"

     

       222
       222
       -
       version = "1.7.1"

     

       223
       223
       -
       source = { registry = "https://pypi.org/simple" }

     

       224
       224
       -
       sdist = { url = "https://files.pythonhosted.org/packages/85/4d/6c9ef746dfcc2a32e26f3860bb4a011c008c392b83eabdfb598d1a8bbe5d/configargparse-1.7.1.tar.gz", hash = "sha256:79c2ddae836a1e5914b71d58e4b9adbd9f7779d4e6351a637b7d2d9b6c46d3d9", size = 43958, upload-time = "2025-05-23T14:26:17.369Z" }

     

       225
       225
       -
       wheels = [

     

       226
       226
       -
           { url = "https://files.pythonhosted.org/packages/31/28/d28211d29bcc3620b1fece85a65ce5bb22f18670a03cd28ea4b75ede270c/configargparse-1.7.1-py3-none-any.whl", hash = "sha256:8b586a31f9d873abd1ca527ffbe58863c99f36d896e2829779803125e83be4b6", size = 25607, upload-time = "2025-05-23T14:26:15.923Z" },

     

       227
       227
       -
       ]

     

       228
       228
       -
       

     

       229
       229
       -
       [[package]]

     

       230
       230
       -
       name = "configobj"

     

       231
       231
       -
       version = "5.0.9"

     

       232
       232
       -
       source = { registry = "https://pypi.org/simple" }

     

       233
       233
       -
       sdist = { url = "https://files.pythonhosted.org/packages/f5/c4/c7f9e41bc2e5f8eeae4a08a01c91b2aea3dfab40a3e14b25e87e7db8d501/configobj-5.0.9.tar.gz", hash = "sha256:03c881bbf23aa07bccf1b837005975993c4ab4427ba57f959afdd9d1a2386848", size = 101518, upload-time = "2024-09-21T12:47:46.315Z" }

     

       234
       234
       -
       wheels = [

     

       235
       235
       -
           { url = "https://files.pythonhosted.org/packages/a6/c4/0679472c60052c27efa612b4cd3ddd2a23e885dcdc73461781d2c802d39e/configobj-5.0.9-py2.py3-none-any.whl", hash = "sha256:1ba10c5b6ee16229c79a05047aeda2b55eb4e80d7c7d8ecf17ec1ca600c79882", size = 35615, upload-time = "2024-11-26T14:03:32.972Z" },

     

       236
       236
       -
       ]

     

       237
       237
       -
       

     

       238
       238
       -
       [[package]]

     

       239
       239
       -
       name = "cryptography"

     

       240
       240
       -
       version = "45.0.6"

     

       241
       241
       -
       source = { registry = "https://pypi.org/simple" }

     

       242
       242
       -
       dependencies = [

     

       243
       243
       -
           { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },

     

       244
       244
       -
       ]

     

       245
       245
       -
       sdist = { url = "https://files.pythonhosted.org/packages/d6/0d/d13399c94234ee8f3df384819dc67e0c5ce215fb751d567a55a1f4b028c7/cryptography-45.0.6.tar.gz", hash = "sha256:5c966c732cf6e4a276ce83b6e4c729edda2df6929083a952cc7da973c539c719", size = 744949, upload-time = "2025-08-05T23:59:27.93Z" }

     

       246
       246
       -
       wheels = [

     

       247
       247
       -
           { url = "https://files.pythonhosted.org/packages/8c/29/2793d178d0eda1ca4a09a7c4e09a5185e75738cc6d526433e8663b460ea6/cryptography-45.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:048e7ad9e08cf4c0ab07ff7f36cc3115924e22e2266e034450a890d9e312dd74", size = 7042702, upload-time = "2025-08-05T23:58:23.464Z" },

     

       248
       248
       -
           { url = "https://files.pythonhosted.org/packages/b3/b6/cabd07410f222f32c8d55486c464f432808abaa1f12af9afcbe8f2f19030/cryptography-45.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44647c5d796f5fc042bbc6d61307d04bf29bccb74d188f18051b635f20a9c75f", size = 4206483, upload-time = "2025-08-05T23:58:27.132Z" },

     

       249
       249
       -
           { url = "https://files.pythonhosted.org/packages/8b/9e/f9c7d36a38b1cfeb1cc74849aabe9bf817990f7603ff6eb485e0d70e0b27/cryptography-45.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e40b80ecf35ec265c452eea0ba94c9587ca763e739b8e559c128d23bff7ebbbf", size = 4429679, upload-time = "2025-08-05T23:58:29.152Z" },

     

       250
       250
       -
           { url = "https://files.pythonhosted.org/packages/9c/2a/4434c17eb32ef30b254b9e8b9830cee4e516f08b47fdd291c5b1255b8101/cryptography-45.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:00e8724bdad672d75e6f069b27970883179bd472cd24a63f6e620ca7e41cc0c5", size = 4210553, upload-time = "2025-08-05T23:58:30.596Z" },

     

       251
       251
       -
           { url = "https://files.pythonhosted.org/packages/ef/1d/09a5df8e0c4b7970f5d1f3aff1b640df6d4be28a64cae970d56c6cf1c772/cryptography-45.0.6-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a3085d1b319d35296176af31c90338eeb2ddac8104661df79f80e1d9787b8b2", size = 3894499, upload-time = "2025-08-05T23:58:32.03Z" },

     

       252
       252
       -
           { url = "https://files.pythonhosted.org/packages/79/62/120842ab20d9150a9d3a6bdc07fe2870384e82f5266d41c53b08a3a96b34/cryptography-45.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1b7fa6a1c1188c7ee32e47590d16a5a0646270921f8020efc9a511648e1b2e08", size = 4458484, upload-time = "2025-08-05T23:58:33.526Z" },

     

       253
       253
       -
           { url = "https://files.pythonhosted.org/packages/fd/80/1bc3634d45ddfed0871bfba52cf8f1ad724761662a0c792b97a951fb1b30/cryptography-45.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:275ba5cc0d9e320cd70f8e7b96d9e59903c815ca579ab96c1e37278d231fc402", size = 4210281, upload-time = "2025-08-05T23:58:35.445Z" },

     

       254
       254
       -
           { url = "https://files.pythonhosted.org/packages/7d/fe/ffb12c2d83d0ee625f124880a1f023b5878f79da92e64c37962bbbe35f3f/cryptography-45.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f4028f29a9f38a2025abedb2e409973709c660d44319c61762202206ed577c42", size = 4456890, upload-time = "2025-08-05T23:58:36.923Z" },

     

       255
       255
       -
           { url = "https://files.pythonhosted.org/packages/8c/8e/b3f3fe0dc82c77a0deb5f493b23311e09193f2268b77196ec0f7a36e3f3e/cryptography-45.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ee411a1b977f40bd075392c80c10b58025ee5c6b47a822a33c1198598a7a5f05", size = 4333247, upload-time = "2025-08-05T23:58:38.781Z" },

     

       256
       256
       -
           { url = "https://files.pythonhosted.org/packages/b3/a6/c3ef2ab9e334da27a1d7b56af4a2417d77e7806b2e0f90d6267ce120d2e4/cryptography-45.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e2a21a8eda2d86bb604934b6b37691585bd095c1f788530c1fcefc53a82b3453", size = 4565045, upload-time = "2025-08-05T23:58:40.415Z" },

     

       257
       257
       -
           { url = "https://files.pythonhosted.org/packages/31/c3/77722446b13fa71dddd820a5faab4ce6db49e7e0bf8312ef4192a3f78e2f/cryptography-45.0.6-cp311-abi3-win32.whl", hash = "sha256:d063341378d7ee9c91f9d23b431a3502fc8bfacd54ef0a27baa72a0843b29159", size = 2928923, upload-time = "2025-08-05T23:58:41.919Z" },

     

       258
       258
       -
           { url = "https://files.pythonhosted.org/packages/38/63/a025c3225188a811b82932a4dcc8457a26c3729d81578ccecbcce2cb784e/cryptography-45.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:833dc32dfc1e39b7376a87b9a6a4288a10aae234631268486558920029b086ec", size = 3403805, upload-time = "2025-08-05T23:58:43.792Z" },

     

       259
       259
       -
           { url = "https://files.pythonhosted.org/packages/5b/af/bcfbea93a30809f126d51c074ee0fac5bd9d57d068edf56c2a73abedbea4/cryptography-45.0.6-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:3436128a60a5e5490603ab2adbabc8763613f638513ffa7d311c900a8349a2a0", size = 7020111, upload-time = "2025-08-05T23:58:45.316Z" },

     

       260
       260
       -
           { url = "https://files.pythonhosted.org/packages/98/c6/ea5173689e014f1a8470899cd5beeb358e22bb3cf5a876060f9d1ca78af4/cryptography-45.0.6-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0d9ef57b6768d9fa58e92f4947cea96ade1233c0e236db22ba44748ffedca394", size = 4198169, upload-time = "2025-08-05T23:58:47.121Z" },

     

       261
       261
       -
           { url = "https://files.pythonhosted.org/packages/ba/73/b12995edc0c7e2311ffb57ebd3b351f6b268fed37d93bfc6f9856e01c473/cryptography-45.0.6-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea3c42f2016a5bbf71825537c2ad753f2870191134933196bee408aac397b3d9", size = 4421273, upload-time = "2025-08-05T23:58:48.557Z" },

     

       262
       262
       -
           { url = "https://files.pythonhosted.org/packages/f7/6e/286894f6f71926bc0da67408c853dd9ba953f662dcb70993a59fd499f111/cryptography-45.0.6-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:20ae4906a13716139d6d762ceb3e0e7e110f7955f3bc3876e3a07f5daadec5f3", size = 4199211, upload-time = "2025-08-05T23:58:50.139Z" },

     

       263
       263
       -
           { url = "https://files.pythonhosted.org/packages/de/34/a7f55e39b9623c5cb571d77a6a90387fe557908ffc44f6872f26ca8ae270/cryptography-45.0.6-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dac5ec199038b8e131365e2324c03d20e97fe214af051d20c49db129844e8b3", size = 3883732, upload-time = "2025-08-05T23:58:52.253Z" },

     

       264
       264
       -
           { url = "https://files.pythonhosted.org/packages/f9/b9/c6d32edbcba0cd9f5df90f29ed46a65c4631c4fbe11187feb9169c6ff506/cryptography-45.0.6-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:18f878a34b90d688982e43f4b700408b478102dd58b3e39de21b5ebf6509c301", size = 4450655, upload-time = "2025-08-05T23:58:53.848Z" },

     

       265
       265
       -
           { url = "https://files.pythonhosted.org/packages/77/2d/09b097adfdee0227cfd4c699b3375a842080f065bab9014248933497c3f9/cryptography-45.0.6-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5bd6020c80c5b2b2242d6c48487d7b85700f5e0038e67b29d706f98440d66eb5", size = 4198956, upload-time = "2025-08-05T23:58:55.209Z" },

     

       266
       266
       -
           { url = "https://files.pythonhosted.org/packages/55/66/061ec6689207d54effdff535bbdf85cc380d32dd5377173085812565cf38/cryptography-45.0.6-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:eccddbd986e43014263eda489abbddfbc287af5cddfd690477993dbb31e31016", size = 4449859, upload-time = "2025-08-05T23:58:56.639Z" },

     

       267
       267
       -
           { url = "https://files.pythonhosted.org/packages/41/ff/e7d5a2ad2d035e5a2af116e1a3adb4d8fcd0be92a18032917a089c6e5028/cryptography-45.0.6-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:550ae02148206beb722cfe4ef0933f9352bab26b087af00e48fdfb9ade35c5b3", size = 4320254, upload-time = "2025-08-05T23:58:58.833Z" },

     

       268
       268
       -
           { url = "https://files.pythonhosted.org/packages/82/27/092d311af22095d288f4db89fcaebadfb2f28944f3d790a4cf51fe5ddaeb/cryptography-45.0.6-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5b64e668fc3528e77efa51ca70fadcd6610e8ab231e3e06ae2bab3b31c2b8ed9", size = 4554815, upload-time = "2025-08-05T23:59:00.283Z" },

     

       269
       269
       -
           { url = "https://files.pythonhosted.org/packages/7e/01/aa2f4940262d588a8fdf4edabe4cda45854d00ebc6eaac12568b3a491a16/cryptography-45.0.6-cp37-abi3-win32.whl", hash = "sha256:780c40fb751c7d2b0c6786ceee6b6f871e86e8718a8ff4bc35073ac353c7cd02", size = 2912147, upload-time = "2025-08-05T23:59:01.716Z" },

     

       270
       270
       -
           { url = "https://files.pythonhosted.org/packages/0a/bc/16e0276078c2de3ceef6b5a34b965f4436215efac45313df90d55f0ba2d2/cryptography-45.0.6-cp37-abi3-win_amd64.whl", hash = "sha256:20d15aed3ee522faac1a39fbfdfee25d17b1284bafd808e1640a74846d7c4d1b", size = 3390459, upload-time = "2025-08-05T23:59:03.358Z" },

     

       271
       271
       -
           { url = "https://files.pythonhosted.org/packages/61/69/c252de4ec047ba2f567ecb53149410219577d408c2aea9c989acae7eafce/cryptography-45.0.6-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fc022c1fa5acff6def2fc6d7819bbbd31ccddfe67d075331a65d9cfb28a20983", size = 3584669, upload-time = "2025-08-05T23:59:15.431Z" },

     

       272
       272
       -
           { url = "https://files.pythonhosted.org/packages/e3/fe/deea71e9f310a31fe0a6bfee670955152128d309ea2d1c79e2a5ae0f0401/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:3de77e4df42ac8d4e4d6cdb342d989803ad37707cf8f3fbf7b088c9cbdd46427", size = 4153022, upload-time = "2025-08-05T23:59:16.954Z" },

     

       273
       273
       -
           { url = "https://files.pythonhosted.org/packages/60/45/a77452f5e49cb580feedba6606d66ae7b82c128947aa754533b3d1bd44b0/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:599c8d7df950aa68baa7e98f7b73f4f414c9f02d0e8104a30c0182a07732638b", size = 4386802, upload-time = "2025-08-05T23:59:18.55Z" },

     

       274
       274
       -
           { url = "https://files.pythonhosted.org/packages/a3/b9/a2f747d2acd5e3075fdf5c145c7c3568895daaa38b3b0c960ef830db6cdc/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:31a2b9a10530a1cb04ffd6aa1cd4d3be9ed49f7d77a4dafe198f3b382f41545c", size = 4152706, upload-time = "2025-08-05T23:59:20.044Z" },

     

       275
       275
       -
           { url = "https://files.pythonhosted.org/packages/81/ec/381b3e8d0685a3f3f304a382aa3dfce36af2d76467da0fd4bb21ddccc7b2/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:e5b3dda1b00fb41da3af4c5ef3f922a200e33ee5ba0f0bc9ecf0b0c173958385", size = 4386740, upload-time = "2025-08-05T23:59:21.525Z" },

     

       276
       276
       -
           { url = "https://files.pythonhosted.org/packages/0a/76/cf8d69da8d0b5ecb0db406f24a63a3f69ba5e791a11b782aeeefef27ccbb/cryptography-45.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:629127cfdcdc6806dfe234734d7cb8ac54edaf572148274fa377a7d3405b0043", size = 3331874, upload-time = "2025-08-05T23:59:23.017Z" },

     

       277
       277
       -
       ]

     

       278
       278
       -
       

     

       279
       279
       -
       [[package]]

     

       280
       140
        
       name = "distro"

     

       281
       141
        
       version = "1.9.0"

     

       282
       142
        
       source = { registry = "https://pypi.org/simple" }

     
···

       384
       244
        
       ]

     

       385
       245
        
       

     

       386
       246
        
       [[package]]

     

       387
       387
       -
       name = "josepy"

     

       388
       388
       -
       version = "2.1.0"

     

       389
       389
       -
       source = { registry = "https://pypi.org/simple" }

     

       390
       390
       -
       dependencies = [

     

       391
       391
       -
           { name = "cryptography" },

     

       392
       392
       -
       ]

     

       393
       393
       -
       sdist = { url = "https://files.pythonhosted.org/packages/9d/19/4ebe24c42c341c5868dff072b78d503fc1b0725d88ea619d2db68f5624a9/josepy-2.1.0.tar.gz", hash = "sha256:9beafbaa107ec7128e6c21d86b2bc2aea2f590158e50aca972dca3753046091f", size = 56189, upload-time = "2025-07-08T17:20:54.98Z" }

     

       394
       394
       -
       wheels = [

     

       395
       395
       -
           { url = "https://files.pythonhosted.org/packages/47/0e/e248f059986e376b87e546cd840d244370b9f7ef2b336456f0c2cfb2fef0/josepy-2.1.0-py3-none-any.whl", hash = "sha256:0eadf09b96821bdae9a8b14145425cb9fe0bbee64c6fdfce3ccd4ceb7d7efbbd", size = 29065, upload-time = "2025-07-08T17:20:53.504Z" },

     

       396
       396
       -
       ]

     

       397
       397
       -
       

     

       398
       398
       -
       [[package]]

     

       399
       247
        
       name = "mypy-extensions"

     

       400
       248
        
       version = "1.1.0"

     

       401
       249
        
       source = { registry = "https://pypi.org/simple" }

     
···

       409
       257
        
       version = "0.1.0"

     

       410
       258
        
       source = { editable = "." }

     

       411
       259
        
       dependencies = [

     

       412
       412
       -
           { name = "certbot" },

     

       413
       413
       -
           { name = "cryptography" },

     

       414
       260
        
           { name = "fastapi" },

     

       415
       261
        
           { name = "pydantic" },

     

       416
       262
        
           { name = "python-dotenv" },

     
···

       439
       285
        
       [package.metadata]

     

       440
       286
        
       requires-dist = [

     

       441
       287
        
           { name = "black", marker = "extra == 'dev'", specifier = ">=23.0.0" },

     

       442
       442
       -
           { name = "certbot", specifier = ">=2.8.0" },

     

       443
       443
       -
           { name = "cryptography", specifier = ">=41.0.0" },

     

       444
       288
        
           { name = "fastapi", specifier = ">=0.104.0" },

     

       445
       289
        
           { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.25.0" },

     

       446
       290
        
           { name = "pydantic", specifier = ">=2.5.0" },

     
···

       472
       316
        
       ]

     

       473
       317
        
       

     

       474
       318
        
       [[package]]

     

       475
       475
       -
       name = "parsedatetime"

     

       476
       476
       -
       version = "2.6"

     

       477
       477
       -
       source = { registry = "https://pypi.org/simple" }

     

       478
       478
       -
       sdist = { url = "https://files.pythonhosted.org/packages/a8/20/cb587f6672dbe585d101f590c3871d16e7aec5a576a1694997a3777312ac/parsedatetime-2.6.tar.gz", hash = "sha256:4cb368fbb18a0b7231f4d76119165451c8d2e35951455dfee97c62a87b04d455", size = 60114, upload-time = "2020-05-31T23:50:57.443Z" }

     

       479
       479
       -
       wheels = [

     

       480
       480
       -
           { url = "https://files.pythonhosted.org/packages/9d/a4/3dd804926a42537bf69fb3ebb9fd72a50ba84f807d95df5ae016606c976c/parsedatetime-2.6-py3-none-any.whl", hash = "sha256:cb96edd7016872f58479e35879294258c71437195760746faffedb692aef000b", size = 42548, upload-time = "2020-05-31T23:50:56.315Z" },

     

       481
       481
       -
       ]

     

       482
       482
       -
       

     

       483
       483
       -
       [[package]]

     

       484
       319
        
       name = "pathspec"

     

       485
       320
        
       version = "0.12.1"

     

       486
       321
        
       source = { registry = "https://pypi.org/simple" }

     
···

       505
       340
        
       sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }

     

       506
       341
        
       wheels = [

     

       507
       342
        
           { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },

     

       508
       508
       -
       ]

     

       509
       509
       -
       

     

       510
       510
       -
       [[package]]

     

       511
       511
       -
       name = "pycparser"

     

       512
       512
       -
       version = "2.22"

     

       513
       513
       -
       source = { registry = "https://pypi.org/simple" }

     

       514
       514
       -
       sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }

     

       515
       515
       -
       wheels = [

     

       516
       516
       -
           { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },

     

       517
       343
        
       ]

     

       518
       344
        
       

     

       519
       345
        
       [[package]]

     
···

       606
       432
        
       ]

     

       607
       433
        
       

     

       608
       434
        
       [[package]]

     

       609
       609
       -
       name = "pyopenssl"

     

       610
       610
       -
       version = "25.1.0"

     

       611
       611
       -
       source = { registry = "https://pypi.org/simple" }

     

       612
       612
       -
       dependencies = [

     

       613
       613
       -
           { name = "cryptography" },

     

       614
       614
       -
           { name = "typing-extensions", marker = "python_full_version < '3.13'" },

     

       615
       615
       -
       ]

     

       616
       616
       -
       sdist = { url = "https://files.pythonhosted.org/packages/04/8c/cd89ad05804f8e3c17dea8f178c3f40eeab5694c30e0c9f5bcd49f576fc3/pyopenssl-25.1.0.tar.gz", hash = "sha256:8d031884482e0c67ee92bf9a4d8cceb08d92aba7136432ffb0703c5280fc205b", size = 179937, upload-time = "2025-05-17T16:28:31.31Z" }

     

       617
       617
       -
       wheels = [

     

       618
       618
       -
           { url = "https://files.pythonhosted.org/packages/80/28/2659c02301b9500751f8d42f9a6632e1508aa5120de5e43042b8b30f8d5d/pyopenssl-25.1.0-py3-none-any.whl", hash = "sha256:2b11f239acc47ac2e5aca04fd7fa829800aeee22a2eb30d744572a157bd8a1ab", size = 56771, upload-time = "2025-05-17T16:28:29.197Z" },

     

       619
       619
       -
       ]

     

       620
       620
       -
       

     

       621
       621
       -
       [[package]]

     

       622
       622
       -
       name = "pyrfc3339"

     

       623
       623
       -
       version = "2.0.1"

     

       624
       624
       -
       source = { registry = "https://pypi.org/simple" }

     

       625
       625
       -
       sdist = { url = "https://files.pythonhosted.org/packages/f0/d2/6587e8ec3951cbd97c56333d11e0f8a3a4cb64c0d6ed101882b7b31c431f/pyrfc3339-2.0.1.tar.gz", hash = "sha256:e47843379ea35c1296c3b6c67a948a1a490ae0584edfcbdea0eaffb5dd29960b", size = 4573, upload-time = "2024-11-04T01:57:09.959Z" }

     

       626
       626
       -
       wheels = [

     

       627
       627
       -
           { url = "https://files.pythonhosted.org/packages/dd/ba/d778be0f6d8d583307b47ba481c95f88a59d5c6dfd5d136bc56656d1d17f/pyRFC3339-2.0.1-py3-none-any.whl", hash = "sha256:30b70a366acac3df7386b558c21af871522560ed7f3f73cf344b8c2cbb8b0c9d", size = 5777, upload-time = "2024-11-04T01:57:08.185Z" },

     

       628
       628
       -
       ]

     

       629
       629
       -
       

     

       630
       630
       -
       [[package]]

     

       631
       435
        
       name = "pytest"

     

       632
       436
        
       version = "8.4.1"

     

       633
       437
        
       source = { registry = "https://pypi.org/simple" }

     
···

       671
       475
        
       sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" }

     

       672
       476
        
       wheels = [

     

       673
       477
        
           { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" },

     

       674
       674
       -
       ]

     

       675
       675
       -
       

     

       676
       676
       -
       [[package]]

     

       677
       677
       -
       name = "pywin32"

     

       678
       678
       -
       version = "311"

     

       679
       679
       -
       source = { registry = "https://pypi.org/simple" }

     

       680
       680
       -
       wheels = [

     

       681
       681
       -
           { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" },

     

       682
       682
       -
           { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" },

     

       683
       683
       -
           { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" },

     

       684
       684
       -
           { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" },

     

       685
       685
       -
           { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" },

     

       686
       686
       -
           { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" },

     

       687
       687
       -
           { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },

     

       688
       688
       -
           { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },

     

       689
       689
       -
           { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },

     

       690
       690
       -
           { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },

     

       691
       691
       -
           { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },

     

       692
       692
       -
           { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },

     

       693
       478
        
       ]

     

       694
       479
        
       

     

       695
       480
        
       [[package]]

Compare changes