wtf is going on with these imports man

.env.example

@@ -1,72 +0,0 @@
-# studspider Environment Configuration
-
-# ============================================================================
-# Square API Configuration
-# ============================================================================
-
-# Environment: "production" or "sandbox"
-SQUARE_ENV=sandbox
-
-# Sandbox credentials
-SANDBOX_SQUARE_APP_ID=your_sandbox_app_id
-SANDBOX_SQUARE_TOKEN=your_sandbox_access_token
-
-# Production credentials
-PROD_SQUARE_APP_ID=your_production_app_id
-PROD_SQUARE_TOKEN=your_production_access_token
-
-# Square LEGO category ID (find this in Square Dashboard)
-SQUARE_LEGO_CAT_ID=your_lego_category_id
-
-# ============================================================================
-# Brickset API Configuration
-# ============================================================================
-
-BRICKSET_USERNAME=your_brickset_username
-BRICKSET_PASS=your_brickset_password
-BRICKSET_API_KEY=your_brickset_api_key
-
-# ============================================================================
-# SSL Certificate Configuration (Optional)
-# ============================================================================
-
-# NOTE: Only needed if running HTTPS directly (not recommended with nginx)
-# For nginx reverse proxy setup, leave these empty
-
-# Path to SSL certificate in PEM format
-# SSL_CERT_PATH=/path/to/cert.pem
-
-# Path to SSL private key in PEM format
-# SSL_KEY_PATH=/path/to/key.pem
-
-# ============================================================================
-# Square Webhook Certificate (P7B Format)
-# ============================================================================
-
-# Path to P7B certificate file for Square webhook signature verification
-# This file is UPLOADED to Square Dashboard, not used by your server
-# Generate with: python convert_to_p7b.py
-SQUARE_P7B_PATH=./cert.p7b
-
-# ============================================================================
-# Server Configuration (Optional)
-# ============================================================================
-
-# Default host and port (can override with command line args)
-# SERVER_HOST=0.0.0.0
-# SERVER_PORT=7432
-# SERVER_HOOK_PORT=8080
-
-# ============================================================================
-# Usage Examples
-# ============================================================================
-
-# Basic HTTP server (recommended with nginx):
-#   python src/test_server.py
-#
-# With SSL from .env:
-#   Set SSL_CERT_PATH and SSL_KEY_PATH above, then:
-#   python src/test_server.py --hook-port 8443 --hook-ssl-only
-#
-# Override SSL from command line:
-#   python src/test_server.py --ssl-cert /custom/cert.pem --ssl-key /custom/key.pem

.gitignore

@@ -25,7 +25,7 @@ square-src.code-workspace
 
 doc/pw-inventory/
 
-studspider.db-journal
+edderkop.db-journal
 .venv
 *.db
 *.py[cod]
@@ -33,8 +33,3 @@ studspider.db-journal
 .states
 assets/external/
 __pycache__/
-win/
-.github/
-bin/
-activate/
-build/

README.md

@@ -1,4 +1,4 @@
-# studspider
+# Edderkop
 
 ![Static Badge](https://img.shields.io/badge/python-3.13.7-blue?logo=python) ![Static Badge](https://img.shields.io/badge/code_style-black-black) ![Static Badge](https://img.shields.io/badge/license-MPL-orange)
 
@@ -11,14 +11,14 @@ is a tool used to talk to brickset.com and a square inventory to pull lego set i
 Clone the project
 
 ```bash
-  git clone http://git.traps.moe/ph0sgene/studspider.git
+  git clone http://git.traps.moe/ph0sgene/edderkop.git
   git checkout uv 
 ```
 
 Go to the project directory
 
 ```bash
-  cd studspider
+  cd edderkop
 ```
 
 Install dependencies
@@ -30,7 +30,7 @@ Install dependencies
 Start the server
 
 ```bash
-  uvx run studspider.py
+  uvx run edderkop.py
 ```
 
 

doc/CERTIFICATE_FORMATS.md

@@ -1,136 +0,0 @@
-# Understanding PEM vs P7B Certificates
-
-## Quick Summary
-
-**You CANNOT use P7B files to run your HTTPS server!**
-
-- **PEM files** = Run your server with HTTPS ✓
-- **P7B files** = Upload to Square Dashboard ✓
-
-## The Complete Picture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    Your HTTPS Server                        │
-│                                                             │
-│  Uses: cert.pem + key.pem (PEM format)                    │
-│  Command: python src/test_server.py                        │
-│           --ssl-cert cert.pem                              │
-│           --ssl-key key.pem                                │
-│           --hook-port 8443                                 │
-└─────────────────────────────────────────────────────────────┘
-                         │
-                         │ HTTPS traffic
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                  Square's Servers                           │
-│                                                             │
-│  They verify your server using: cert.p7b                   │
-│  (which YOU upload to Square Dashboard)                    │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## Why Two Formats?
-
-### PEM Format (.pem files)
-- **Contains**: Certificate AND private key (separate files)
-- **Used by**: Your HTTPS server to encrypt traffic
-- **Files needed**: 
-  - `cert.pem` - Your public certificate
-  - `key.pem` - Your private key (NEVER share this!)
-
-### P7B Format (.p7b files)  
-- **Contains**: Certificate ONLY (no private key)
-- **Used by**: Square to verify webhook signatures
-- **File**: `cert.p7b` - Uploaded to Square Dashboard
-
-## Step-by-Step Workflow
-
-### 1. Generate Certificates (PEM format)
-```powershell
-python generate_cert.py
-```
-**Creates:**
-- `cert.pem` - Your certificate (public)
-- `key.pem` - Your private key (secret!)
-
-### 2. Start Your HTTPS Server (uses PEM)
-```powershell
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only
-```
-**Server runs at:**
-- `https://localhost:8443/hook`
-
-### 3. Convert Certificate to P7B for Square
-```powershell
-python convert_to_p7b.py
-```
-**Creates:**
-- `cert.p7b` - Certificate in P7B format (for Square)
-
-### 4. Upload P7B to Square
-1. Go to: https://developer.squareup.com/apps
-2. Your App → **Webhooks** → **Manage Notification Settings**
-3. Upload `cert.p7b`
-
-### 5. Configure Square Webhook URL
-- Enter: `https://yourdomain.com:8443/hook`
-- Square will verify using the P7B you uploaded
-
-## Common Mistakes
-
-### ❌ Trying to use P7B with your server
-```powershell
-# THIS WON'T WORK!
-python src/test_server.py --ssl-cert cert.p7b --ssl-key key.p7b
-```
-**Error:** P7B doesn't contain the private key needed for HTTPS!
-
-### ✓ Correct usage
-```powershell
-# Server uses PEM files
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443
-
-# P7B file is uploaded to Square Dashboard (not used by your server)
-```
-
-## If You Only Have a P7B File
-
-If someone gave you a P7B file, you can extract the certificate:
-
-```powershell
-python convert_from_p7b.py your_cert.p7b --output cert.pem
-```
-
-**BUT:** You still need the private key (`key.pem`) to run HTTPS!
-
-If you don't have the private key, you must:
-1. Generate a new certificate pair: `python generate_cert.py`
-2. Or get the private key from whoever created the P7B
-
-## File Checklist
-
-To run your HTTPS server with Square webhooks, you need:
-
-- [ ] `cert.pem` - Certificate (PEM format) - For your server
-- [ ] `key.pem` - Private key (PEM format) - For your server  
-- [ ] `cert.p7b` - Certificate (P7B format) - Upload to Square
-
-Generate all three with:
-```powershell
-python generate_cert.py      # Creates cert.pem and key.pem
-python convert_to_p7b.py      # Creates cert.p7b from cert.pem
-```
-
-## Security Notes
-
-- **Never share `key.pem`** - This is your private key!
-- **`cert.pem` is public** - Safe to share
-- **`cert.p7b` is public** - You upload this to Square
-- Self-signed certificates are fine for testing but use Let's Encrypt for production
-
-## Need Help?
-
-See the detailed guides:
-- `HTTPS_SETUP.md` - Complete HTTPS setup instructions
-- `SQUARE_WEBHOOK_SETUP.md` - Square webhook configuration

doc/HTTPS_SETUP.md

@@ -1,166 +0,0 @@
-# HTTPS Webhook Setup Guide
-
-## Quick Start (Self-Signed Certificate for Testing)
-
-### 1. Generate Certificate
-```powershell
-python generate_cert.py
-```
-
-This creates `cert.pem` and `key.pem` files.
-
-### 1.5. Convert to P7B for Square (Required for Square Webhooks)
-```powershell
-python convert_to_p7b.py
-```
-
-This creates `cert.p7b` which Square needs for webhook signature verification.
-Upload this P7B file to Square Developer Dashboard → Webhooks → Manage Notification Settings.
-
-### 2. Run Server with HTTPS
-
-#### Option A: HTTPS for webhook only (recommended for development)
-```powershell
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only
-```
-- Main server: `http://localhost:7432/` (HTTP)
-- Webhook: `https://localhost:8443/hook` (HTTPS)
-
-#### Option B: HTTPS for everything
-```powershell
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443
-```
-- Main server: `https://localhost:7432/` (HTTPS)
-- Webhook: `https://localhost:8443/hook` (HTTPS)
-
-#### Option C: Single port with HTTPS
-```powershell
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem
-```
-- Everything on: `https://localhost:7432/`
-
-### 3. Test the Webhook
-
-Update `src/test_webhook.py` to use HTTPS:
-```python
-url = "https://localhost:8443/hook"
-```
-
-Then run:
-```powershell
-python src/test_webhook.py
-```
-
-## Production Setup (with Real Certificate)
-
-### Option 1: Let's Encrypt (Free, Recommended)
-
-On Linux/WSL:
-```bash
-# Install certbot
-sudo apt-get install certbot
-
-# Generate certificate (replace yourdomain.com)
-sudo certbot certonly --standalone -d yourdomain.com
-
-# Certificates will be at:
-# /etc/letsencrypt/live/yourdomain.com/fullchain.pem
-# /etc/letsencrypt/live/yourdomain.com/privkey.pem
-
-# Run server
-python src/test_server.py \
-  --ssl-cert /etc/letsencrypt/live/yourdomain.com/fullchain.pem \
-  --ssl-key /etc/letsencrypt/live/yourdomain.com/privkey.pem \
-  --host 0.0.0.0 \
-  --hook-port 443 \
-  --hook-ssl-only
-```
-
-### Option 2: Reverse Proxy (nginx/Caddy)
-
-Run studspider on HTTP internally, use nginx/Caddy for HTTPS:
-
-```nginx
-# nginx config
-server {
-    listen 443 ssl;
-    server_name yourdomain.com;
-    
-    ssl_certificate /path/to/cert.pem;
-    ssl_certificate_key /path/to/key.pem;
-    
-    location /hook {
-        proxy_pass http://localhost:7432/hook;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-    }
-}
-```
-
-Then run studspider normally:
-```powershell
-python src/test_server.py
-```
-
-## Troubleshooting
-
-### "OpenSSL not found" Error
-- **Windows**: Install from https://slproweb.com/products/Win32OpenSSL.html
-- **Alternative**: Use Git Bash or WSL which include OpenSSL
-
-### Self-Signed Certificate Warnings
-- Normal for development
-- Use `--insecure` flag with curl/tools for testing
-- For production, get a proper certificate from Let's Encrypt
-
-### Port 443 Already in Use
-- Use a different port like 8443
-- Or stop the service using port 443
-
-### Certificate File Not Found
-- Use absolute paths: `--ssl-cert C:\path\to\cert.pem`
-- Or run from the directory containing the certificates
-
-## Square Webhook Configuration
-
-### Certificate Requirements
-Square requires a **P7B (PKCS#7)** certificate file for webhook signature verification.
-
-### Setup Steps:
-
-1. **Generate your certificate** (if you haven't already):
-   ```powershell
-   python generate_cert.py
-   ```
-
-2. **Convert PEM to P7B format**:
-   ```powershell
-   # Basic conversion
-   python convert_to_p7b.py
-   
-   # With intermediate certificates (production)
-   python convert_to_p7b.py --cert fullchain.pem --chain intermediate.pem --output square.p7b
-   ```
-
-3. **Upload to Square Dashboard**:
-   - Go to https://developer.squareup.com/
-   - Navigate to your application
-   - Click on "Webhooks"
-   - Click "Manage Notification Settings"
-   - Upload the `cert.p7b` file
-   - Square will use this to verify webhook signatures
-
-4. **Configure webhook URL in Square**:
-   - Use your public HTTPS URL: `https://yourdomain.com:8443/hook`
-   - Square requires valid SSL (not self-signed for production)
-
-### Testing with Square Webhooks:
-
-When setting up webhooks in Square Dashboard:
-1. Use your HTTPS URL: `https://yourdomain.com:8443/hook`
-2. Square requires valid SSL (not self-signed)
-3. Consider using ngrok for local testing:
-   ```powershell
-   ngrok http 8443
-   ```
-   Then use the ngrok HTTPS URL in Square Dashboard

doc/NGINX_SETUP.md

@@ -1,356 +0,0 @@
-# Nginx Reverse Proxy Configuration for studspider
-
-## Overview
-
-When using nginx as a reverse proxy:
-- **Nginx handles HTTPS** (SSL/TLS termination)
-- **studspider runs on HTTP** internally (no SSL needed)
-- **nginx forwards requests** to studspider
-
-## Architecture
-
-```
-Internet (HTTPS) → nginx (443) → studspider (7432/HTTP)
-                      ↓
-            Handles SSL certificates
-            Handles HTTPS traffic
-            Forwards to HTTP backend
-```
-
-## Benefits
-
-✓ **No SSL certificates needed in studspider**
-✓ **nginx handles SSL efficiently**
-✓ **Easy certificate renewal** (Let's Encrypt)
-✓ **Better performance** (nginx is optimized for this)
-✓ **Additional security** (rate limiting, IP filtering, etc.)
-
----
-
-## Configuration Examples
-
-### Basic Configuration (HTTP → HTTPS redirect + webhook proxy)
-
-Create `/etc/nginx/sites-available/studspider`:
-
-```nginx
-# Redirect HTTP to HTTPS
-server {
-    listen 80;
-    server_name studspider.sh www.studspider.sh;
-    
-    location / {
-        return 301 https://$host$request_uri;
-    }
-}
-
-# HTTPS server
-server {
-    listen 443 ssl http2;
-    server_name studspider.sh www.studspider.sh;
-
-    # SSL certificates (Let's Encrypt)
-    ssl_certificate /etc/letsencrypt/live/studspider.sh/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/studspider.sh/privkey.pem;
-    
-    # SSL configuration (modern, secure)
-    ssl_protocols TLSv1.2 TLSv1.3;
-    ssl_ciphers HIGH:!aNULL:!MD5;
-    ssl_prefer_server_ciphers on;
-
-    # Logs
-    access_log /var/log/nginx/studspider_access.log;
-    error_log /var/log/nginx/studspider_error.log;
-
-    # Webhook endpoint (Square webhooks)
-    location /hook {
-        proxy_pass http://localhost:7432/hook;
-        
-        # Forward headers
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        
-        # Timeouts
-        proxy_connect_timeout 60s;
-        proxy_send_timeout 60s;
-        proxy_read_timeout 60s;
-        
-        # Disable buffering for real-time responses
-        proxy_buffering off;
-    }
-
-    # Main API endpoint (optional)
-    location / {
-        proxy_pass http://localhost:7432/;
-        
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}
-```
-
-### Separate Port Configuration (webhook on different port)
-
-```nginx
-server {
-    listen 443 ssl http2;
-    server_name studspider.sh;
-
-    ssl_certificate /etc/letsencrypt/live/studspider.sh/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/studspider.sh/privkey.pem;
-
-    # Main API
-    location / {
-        proxy_pass http://localhost:7432/;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto https;
-    }
-}
-
-# Separate server for webhooks on different port
-server {
-    listen 8443 ssl http2;
-    server_name studspider.sh;
-
-    ssl_certificate /etc/letsencrypt/live/studspider.sh/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/studspider.sh/privkey.pem;
-
-    # Webhook only
-    location /hook {
-        proxy_pass http://localhost:8080/hook;  # studspider webhook port
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto https;
-    }
-}
-```
-
-### With Rate Limiting (recommended for webhooks)
-
-```nginx
-# Define rate limit zone (outside server block)
-limit_req_zone $binary_remote_addr zone=webhook_limit:10m rate=10r/s;
-
-server {
-    listen 443 ssl http2;
-    server_name studspider.sh;
-
-    ssl_certificate /etc/letsencrypt/live/studspider.sh/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/studspider.sh/privkey.pem;
-
-    # Webhook with rate limiting
-    location /hook {
-        # Rate limit: 10 requests per second per IP
-        limit_req zone=webhook_limit burst=20 nodelay;
-        
-        # Only allow POST requests
-        limit_except POST {
-            deny all;
-        }
-        
-        proxy_pass http://localhost:7432/hook;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto https;
-    }
-}
-```
-
----
-
-## Setup Steps
-
-### 1. Install nginx (if not already installed)
-
-```bash
-# Ubuntu/Debian
-sudo apt update
-sudo apt install nginx
-
-# CentOS/RHEL
-sudo yum install nginx
-```
-
-### 2. Get SSL Certificate (Let's Encrypt - Free!)
-
-```bash
-# Install certbot
-sudo apt install certbot python3-certbot-nginx
-
-# Get certificate for your domain
-sudo certbot --nginx -d studspider.sh -d www.studspider.sh
-
-# Certbot will automatically:
-# 1. Generate certificate
-# 2. Configure nginx
-# 3. Set up auto-renewal
-```
-
-### 3. Create nginx Configuration
-
-```bash
-# Create config file
-sudo nano /etc/nginx/sites-available/studspider
-
-# Paste one of the configurations above
-
-# Create symbolic link to enable site
-sudo ln -s /etc/nginx/sites-available/studspider /etc/nginx/sites-enabled/
-
-# Test configuration
-sudo nginx -t
-
-# Reload nginx
-sudo systemctl reload nginx
-```
-
-### 4. Start studspider (HTTP only, no SSL needed!)
-
-```bash
-# Simple - single port
-python src/test_server.py --port 7432
-
-# Or with separate webhook port
-python src/test_server.py --port 7432 --hook-port 8080
-```
-
-### 5. Configure Square Webhook URL
-
-In Square Developer Dashboard:
-- **Webhook URL**: `https://studspider.sh/hook`
-- **Certificate**: Upload the P7B file (see below)
-
-### 6. Generate P7B for Square
-
-```bash
-# Convert your Let's Encrypt certificate to P7B for Square
-python convert_to_p7b.py --cert /etc/letsencrypt/live/studspider.sh/fullchain.pem --output square.p7b
-
-# Upload square.p7b to Square Dashboard
-```
-
----
-
-## Systemd Service (Run studspider at boot)
-
-Create `/etc/systemd/system/studspider.service`:
-
-```ini
-[Unit]
-Description=studspider - LEGO Inventory Sync Service
-After=network.target
-
-[Service]
-Type=simple
-User=www-data
-WorkingDirectory=/opt/studspider
-Environment="PATH=/opt/studspider/.venv/bin"
-ExecStart=/opt/studspider/.venv/bin/python src/test_server.py --port 7432
-Restart=always
-RestartSec=10
-
-# Logging
-StandardOutput=append:/var/log/studspider/stdout.log
-StandardError=append:/var/log/studspider/stderr.log
-
-[Install]
-WantedBy=multi-user.target
-```
-
-Enable and start:
-
-```bash
-# Create log directory
-sudo mkdir -p /var/log/studspider
-sudo chown www-data:www-data /var/log/studspider
-
-# Enable service
-sudo systemctl enable studspider
-
-# Start service
-sudo systemctl start studspider
-
-# Check status
-sudo systemctl status studspider
-
-# View logs
-sudo journalctl -u studspider -f
-```
-
----
-
-## Testing
-
-### Test nginx configuration
-```bash
-sudo nginx -t
-```
-
-### Test studspider locally
-```bash
-curl http://localhost:7432/hook -X POST -H "Content-Type: application/json" -d '{"test":"data"}'
-```
-
-### Test through nginx
-```bash
-curl https://studspider.sh/hook -X POST -H "Content-Type: application/json" -d '{"test":"data"}'
-```
-
-### Monitor logs
-```bash
-# nginx logs
-sudo tail -f /var/log/nginx/studspider_access.log
-sudo tail -f /var/log/nginx/studspider_error.log
-
-# studspider logs
-tail -f ./logs/studspider.log
-```
-
----
-
-## Troubleshooting
-
-### 502 Bad Gateway
-- Check if studspider is running: `ps aux | grep test_server.py`
-- Check the port matches nginx config
-- Check firewall isn't blocking internal connections
-
-### Certificate Errors
-- Ensure Let's Encrypt renewal is working: `sudo certbot renew --dry-run`
-- Check certificate files exist and have correct permissions
-
-### Webhook Not Receiving
-- Verify nginx is forwarding: Check nginx access logs
-- Verify studspider is receiving: Check studspider logs
-- Test locally first, then through nginx
-
-### Connection Refused
-- Check studspider is listening: `sudo netstat -tlnp | grep 7432`
-- Check nginx proxy_pass points to correct host:port
-
----
-
-## Summary
-
-### With nginx reverse proxy:
-
-✓ **studspider runs simple HTTP** (no SSL certificates needed)
-```bash
-python src/test_server.py --port 7432
-```
-
-✓ **nginx handles HTTPS** (manages certificates automatically)
-
-✓ **Square gets HTTPS webhook** (`https://studspider.sh/hook`)
-
-✓ **You upload P7B to Square** (converted from nginx's certificate)
-
-### This is the recommended production setup!

doc/SQUARE_WEBHOOK_SETUP.md

@@ -1,191 +0,0 @@
-# Square Webhook Setup - Quick Reference
-
-## Complete Setup Process
-
-### Step 1: Generate SSL Certificate
-```powershell
-# Generate PEM certificate
-python generate_cert.py
-# Creates: cert.pem, key.pem
-```
-
-### Step 2: Convert to P7B for Square
-```powershell
-# Convert PEM to P7B (PKCS#7) format
-python convert_to_p7b.py
-# Creates: cert.p7b
-```
-
-### Step 3: Start HTTPS Server
-```powershell
-# Start webhook server with HTTPS
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only
-
-# Server URLs:
-# Main:    http://localhost:7432/
-# Webhook: https://localhost:8443/hook (or https://yourdomain.com:8443/hook)
-```
-
-### Step 4: Configure Square Webhook
-
-1. **Upload P7B Certificate to Square:**
-   - Go to: https://developer.squareup.com/apps
-   - Select your application
-   - Navigate to: **Webhooks** → **Manage Notification Settings**
-   - Upload `cert.p7b` file
-   - This allows Square to verify webhook signatures
-
-2. **Add Webhook Subscription:**
-   - Still in Webhooks section
-   - Click **"Add Subscription"**
-   - Enter URL: `https://yourdomain.com:8443/hook`
-   - Select events to subscribe to (e.g., `inventory.count.updated`)
-   - Click **Save**
-
-### Step 5: Test the Webhook
-
-```powershell
-# Test from command line
-python src/test_webhook.py
-
-# Or manually with curl
-curl -X POST https://localhost:8443/hook \
-  -H "Content-Type: application/json" \
-  -d '{"type":"inventory.count.updated","merchant_id":"test"}'
-```
-
-## Production Deployment
-
-### Using Let's Encrypt (Recommended)
-
-```bash
-# 1. Get Let's Encrypt certificate (Linux/WSL)
-sudo certbot certonly --standalone -d yourdomain.com
-
-# 2. Convert to P7B for Square
-python convert_to_p7b.py \
-  --cert /etc/letsencrypt/live/yourdomain.com/fullchain.pem \
-  --output square.p7b
-
-# 3. Upload square.p7b to Square Dashboard
-
-# 4. Run server
-python src/test_server.py \
-  --ssl-cert /etc/letsencrypt/live/yourdomain.com/fullchain.pem \
-  --ssl-key /etc/letsencrypt/live/yourdomain.com/privkey.pem \
-  --host 0.0.0.0 \
-  --hook-port 443 \
-  --hook-ssl-only
-```
-
-### Using ngrok (Easy Testing)
-
-```powershell
-# Terminal 1: Start your server (HTTP is fine)
-python src/test_server.py --hook-port 8080
-
-# Terminal 2: Expose with ngrok (provides HTTPS automatically)
-ngrok http 8080
-
-# Use the ngrok HTTPS URL in Square:
-# Example: https://abc123.ngrok.io/hook
-
-# For P7B certificate with ngrok:
-# ngrok provides its own certificate, so you don't need to upload one to Square
-```
-
-## Webhook Event Types
-
-Common Square webhook events you can subscribe to:
-
-- `inventory.count.updated` - Inventory quantity changes
-- `catalog.version.updated` - Catalog item updates
-- `payment.created` - New payment received
-- `payment.updated` - Payment status changes
-- `order.created` - New order created
-- `order.updated` - Order status changes
-
-## Troubleshooting
-
-### Certificate Upload Fails
-- Ensure file is in P7B format (not PEM)
-- File must be valid PKCS#7 structure
-- Check file isn't corrupted: `openssl pkcs7 -print_certs -in cert.p7b`
-
-### Webhook Not Receiving Data
-1. Check server is running and accessible from internet
-2. Verify URL in Square Dashboard is correct
-3. Check firewall allows incoming traffic on webhook port
-4. Review server logs: `./logs/studspider.log`
-
-### SSL Certificate Errors
-- Self-signed certificates won't work with Square in production
-- Use Let's Encrypt or commercial CA for production
-- Use ngrok for quick testing (provides valid HTTPS)
-
-### Testing Locally
-```powershell
-# Square can't reach localhost - use one of these:
-# 1. ngrok (easiest)
-ngrok http 8443
-
-# 2. Cloudflare Tunnel
-cloudflared tunnel --url http://localhost:8443
-
-# 3. Deploy to cloud (AWS, Azure, DigitalOcean, etc.)
-```
-
-## Verifying Webhook Signatures
-
-Square signs webhook requests. Your server should verify signatures:
-
-```python
-# TODO: Add to hook_handler in test_server.py
-import hmac
-import hashlib
-
-def verify_square_signature(payload: bytes, signature: str, webhook_signature_key: str) -> bool:
-    """Verify Square webhook signature"""
-    computed_signature = hmac.new(
-        webhook_signature_key.encode('utf-8'),
-        payload,
-        hashlib.sha256
-    ).digest()
-    
-    expected_signature = base64.b64decode(signature)
-    return hmac.compare_digest(computed_signature, expected_signature)
-```
-
-Get your webhook signature key from Square Dashboard → Webhooks → Signature Key.
-
-## Environment Variables
-
-Add to your `.env` file:
-
-```env
-# Square Webhook Configuration
-SQUARE_WEBHOOK_SIGNATURE_KEY=your_signature_key_from_square_dashboard
-
-# SSL Certificate Paths (production)
-SSL_CERT_PATH=/path/to/fullchain.pem
-SSL_KEY_PATH=/path/to/privkey.pem
-```
-
-## Commands Quick Reference
-
-```powershell
-# Generate certificate
-python generate_cert.py
-
-# Convert to P7B
-python convert_to_p7b.py
-
-# Start HTTPS server
-python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only
-
-# Test webhook
-python src/test_webhook.py
-
-# Start with ngrok
-ngrok http 8443
-```

edderkop.py

@@ -1,12 +1,12 @@
 import src.test_server
 
 
-class Studspider:
+class edderkop:
     def __init__(self):
-        self.name = "Studspider"
+        self.name = "Edderkop"
         self.version = "0.0.1"
         self.description = """
-        studspider is an application designed to interact with the Brickset API and directly with Square.
+        Edderkop is an application designed to interact with the Brickset API and directly with Square.
         It allows users to search for items, manage collections, and perform various operations related to bricksets.
         """
 

pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-name = "studpider"
+name = "edderkop"
 version = "0.1.0"
 description = ""
 authors = [{ name = "CF", email = "ph0sgene@pm.me" }]

setup.py

@@ -1,19 +1,19 @@
 from setuptools import setup
 
 setup(
-    name="studspider",
+    name='Edderkop',
-    version="0.1",
+    version='0.1',
-    description="Bricket + Square integration application",
+    description='Bricket + Square integration application',
-    author="CF",
+    author='CF',
-    author_email="chris-forst@pm.me",
+    author_email='chris-forst@pm.me',
-    packages=["src"],
+    packages=['src'],
-    package_dir={"": "src"},
+    package_dir={'': 'src'},
     install_requires=[
         # List your project dependencies here
     ],
     entry_points={
-        "console_scripts": [
+        'console_scripts': [
-            "main=main:main",  # Adjust this line based on your main function
+            'main=main:main',  # Adjust this line based on your main function
         ],
     },
 )

src/abricksetapi.py

@@ -9,8 +9,7 @@ import aiohttp
 import json
 import dotenv
 from typing import Dict, Any
-import throttler
+from . import throttler 
-
 Throttler = throttler.GlobalThrottler
 
 dotenv.load_dotenv()
@@ -24,7 +23,7 @@ class AsyncBricksetAPI:
         self.password = os.getenv("BRICKSET_PASS")
         self.api_key = os.getenv("BRICKSET_API_KEY")
         self.debug = debug
-        self.headers = {"UserAgent": "studspider/0.1"}
+        self.headers = {"UserAgent": "Edderkop/0.1"}
         self.throttler = Throttler(rate_limit=500, period=60)
         self.user_hash = None
         self.logger = logger

src/asquare.py

@@ -6,9 +6,9 @@ import uuid
 import re
 from time import time
 
-import db
+from . import db
 
-import get_sq_env
+from . import get_sq_env
 
 
 def get_set_number(text: str) -> int:
@@ -106,14 +106,10 @@ async def acat2id(cat_id: str):
         {
             "id": obj["id"],
             "name": obj.get("item_data", {}).get("name", "Unknown"),
-            "number": (
+            "number": None if not obj.get("item_data", {}).get("name", "") else (
-                None
-                if not obj.get("item_data", {}).get("name", "")
-                else (
                 get_set_number(obj.get("item_data", {}).get("name", "")) 
                 if re.findall(r"\d{5}", obj.get("item_data", {}).get("name", "")) 
                 else None
-                )
             ),
             "updated_at": obj.get("updated_at"),
             "version": obj.get("version"),

src/bricksetapi.py

@@ -14,9 +14,9 @@ debug = False  # Set to True to enable debug output
 
 def login(username, password):
     url = "https://brickset.com/api/v3.asmx/login"
-    headers = {"UserAgent": "studspider/0.1"}
+    headers = {"UserAgent": "Edderkop/0.1"}
     params = {
-        "UserAgent": "studspider/0.1",
+        "UserAgent": "Edderkop/0.1",
         "username": username,
         "password": password,
         "apiKey": BRICKSET_API_KEY,

src/db.py

@@ -1,15 +1,12 @@
 import aiosqlite
 from time import time
-
 time = int(time())  # we dont need no stinkin floats
 
-# db = await aiosqlite.connect("studspider.db")  # type: ignore
+# db = await aiosqlite.connect("edderkop.db")  # type: ignore
-
 
 async def close(db):
     await db.close()
 
-
 async def fetch(table, sqobj):
     """
     Asynchronously fetch a record from the REVIEW table by sq_object.
@@ -19,16 +16,13 @@ async def fetch(table, sqobj):
     Returns:
         dict or None: The fetched record as a dictionary, or None if not found.
     """
-    async with aiosqlite.connect("studspider.db") as db:  # type: ignore
+    async with aiosqlite.connect("edderkop.db") as db:  # type: ignore
-        async with db.execute(
+        async with db.execute(f"SELECT * FROM {table} WHERE sq_object = {sqobj}") as cursor:
-            f"SELECT * FROM {table} WHERE sq_object = {sqobj}"
-        ) as cursor:
             async for row in cursor:
                 return row
 
     return None
 
-
 async def upsert(table: str, data: dict, unique_key: str) -> bool:
     """
     Asynchronously insert or update a record in the specified table.
@@ -43,11 +37,9 @@ async def upsert(table: str, data: dict, unique_key: str) -> bool:
     """
     print(f"Upserting into {table}: {data}")
 
-    columns = ", ".join(data.keys())
+    columns = ', '.join(data.keys())
-    placeholders = ", ".join("?" * len(data))
+    placeholders = ', '.join('?' * len(data))
-    updates = ", ".join(
+    updates = ', '.join(f"{col}=excluded.{col}" for col in data.keys() if col != unique_key)
-        f"{col}=excluded.{col}" for col in data.keys() if col != unique_key
-    )
 
     sql = f"""
     INSERT INTO {table} ({columns})
@@ -55,7 +47,7 @@ async def upsert(table: str, data: dict, unique_key: str) -> bool:
     ON CONFLICT({unique_key}) DO UPDATE SET
     {updates};
     """
-    async with aiosqlite.connect("studspider.db") as db:  # type: ignore
+    async with aiosqlite.connect("edderkop.db") as db:  # type: ignore
         async with db.execute(sql, tuple(data.values())) as cursor:
             await db.commit()
     return True

src/ebricksetapi.py

@@ -15,7 +15,7 @@ class BricksetAPI:
         self.password = os.getenv("BRICKSET_PASS")
         self.api_key = os.getenv("BRICKSET_API_KEY")
         self.debug = debug
-        self.headers = {"UserAgent": "studspider/0.1"}
+        self.headers = {"UserAgent": "Edderkop/0.1"}
         self.user_hash = None
 
     def login(self) -> Dict[str, Any]:

src/get_sq_env.py

@@ -6,14 +6,6 @@ dotenv.load_dotenv()
 
 LEGO_CAT_ID = os.getenv("SQUARE_LEGO_CAT_ID")
 
-# SSL Certificate paths (optional - for direct HTTPS, not needed with nginx)
-SSL_CERT_PATH = os.getenv("SSL_CERT_PATH")
-SSL_KEY_PATH = os.getenv("SSL_KEY_PATH")
-
-# P7B certificate for Square webhook signature verification
-# This is uploaded to Square Dashboard, not used by the server
-SQUARE_P7B_PATH = os.getenv("SQUARE_P7B_PATH")
-
 if os.getenv("SQUARE_ENV") == "production":
     SQUARE_APP_ID = os.getenv("PROD_SQUARE_APP_ID")
     SQUARE_TOKEN = os.getenv("PROD_SQUARE_TOKEN")

src/scheduler.py

@@ -6,21 +6,21 @@ import os
 
 logger = logging.getLogger(__name__)
 
-# Get the absolute path to studspider.db in the project root
+# Get the absolute path to edderkop.db in the project root
 DEFAULT_DB_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(__file__)), "studspider.db"
+    os.path.dirname(os.path.dirname(__file__)), "edderkop.db"
 )
 
 if not os.path.exists(DEFAULT_DB_PATH):
     raise FileNotFoundError(f"Database file not found at {DEFAULT_DB_PATH}")
-    print('Please run "src/scripts/studspider.SQL" to setup the database.')
+    print('Please run "src/scripts/EDDERKOP.SQL" to setup the database.')
     os.exit(0)
 
 
 class AsyncSchedulerDB:
     """
     Asynchronous SQLite database manager for APScheduler.
-    Handles job storage, retrieval, and database operations using the main studspider.db database.
+    Handles job storage, retrieval, and database operations using the main edderkop.db database.
     """
 
     def __init__(self, db_path: str = DEFAULT_DB_PATH):
@@ -29,7 +29,7 @@ class AsyncSchedulerDB:
 
         Args:
             db_path (str, optional): Path to the SQLite database file.
-                                   Defaults to studspider.db in project root.
+                                   Defaults to edderkop.db in project root.
         """
         self.db_path = db_path
         self._initialized = False

src/scripts/convert_from_p7b.py

@@ -1,110 +0,0 @@
-"""
-Convert P7B (PKCS#7) certificate to PEM format for use with the server
-Use this if you have a P7B file and need to extract PEM certificates
-"""
-
-import subprocess
-import sys
-import os
-
-
-def convert_p7b_to_pem(p7b_file, cert_output="cert.pem", extract_key=False):
-    """
-    Convert P7B certificate to PEM format
-
-    Args:
-        p7b_file: Input P7B (PKCS#7) file
-        cert_output: Output PEM certificate file
-        extract_key: If True, try to extract private key (rarely works with P7B)
-    """
-
-    # Check if OpenSSL is available
-    try:
-        subprocess.run(["openssl", "version"], capture_output=True, check=True)
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print("ERROR: OpenSSL not found!")
-        print("\nFor Windows, you can:")
-        print(
-            "1. Install OpenSSL from: https://slproweb.com/products/Win32OpenSSL.html"
-        )
-        print("2. Or use Git Bash which includes OpenSSL")
-        print("3. Or use WSL (Windows Subsystem for Linux)")
-        return False
-
-    # Check if input file exists
-    if not os.path.exists(p7b_file):
-        print(f"ERROR: P7B file not found: {p7b_file}")
-        print(f"Current directory: {os.getcwd()}")
-        return False
-
-    print(f"Converting {p7b_file} to PEM format...")
-
-    # Convert P7B to PEM
-    cmd = ["openssl", "pkcs7", "-print_certs", "-in", p7b_file, "-out", cert_output]
-
-    try:
-        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
-
-        if os.path.exists(cert_output):
-            print(f"\n✓ PEM certificate created: {os.path.abspath(cert_output)}")
-            print(f"  File size: {os.path.getsize(cert_output)} bytes")
-
-            # Check what was extracted
-            with open(cert_output, "r") as f:
-                content = f.read()
-                cert_count = content.count("BEGIN CERTIFICATE")
-                print(f"  Certificates found: {cert_count}")
-
-            print("\n" + "=" * 60)
-            print("IMPORTANT:")
-            print("=" * 60)
-            print("⚠️  P7B files usually contain ONLY certificates, not private keys!")
-            print("\nTo run an HTTPS server, you need:")
-            print("1. Certificate (cert.pem) - ✓ Extracted")
-            print("2. Private Key (key.pem) - ✗ NOT in P7B file")
-            print("\nIf you don't have the private key:")
-            print("- Generate a new certificate pair: python generate_cert.py")
-            print("- Or obtain the private key from your certificate provider")
-            print("=" * 60)
-
-            return True
-        else:
-            print("ERROR: Output file was not created")
-            return False
-
-    except subprocess.CalledProcessError as e:
-        print(f"ERROR: Conversion failed: {e}")
-        if e.stderr:
-            print(f"OpenSSL error: {e.stderr}")
-        return False
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Convert P7B (PKCS#7) certificate to PEM format"
-    )
-    parser.add_argument("p7b_file", help="Input P7B certificate file")
-    parser.add_argument(
-        "--output",
-        default="cert.pem",
-        help="Output PEM certificate file (default: cert.pem)",
-    )
-
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("P7B to PEM Certificate Converter")
-    print("=" * 60)
-    print()
-
-    success = convert_p7b_to_pem(args.p7b_file, args.output)
-
-    if success:
-        print("\n✓ Conversion complete!")
-        print("\nNext steps:")
-        print("1. If you have the private key separately, use it with --ssl-key")
-        print("2. If not, generate a new certificate: python generate_cert.py")
-    else:
-        sys.exit(1)

src/scripts/convert_to_p7b.py

@@ -1,166 +0,0 @@
-"""
-Convert PEM certificate to P7B (PKCS#7) format for Square webhooks
-Square requires P7B format for webhook signature verification
-"""
-
-import subprocess
-import sys
-import os
-
-
-def convert_pem_to_p7b(cert_file="cert.pem", output_file="cert.p7b"):
-    """
-    Convert PEM certificate to P7B (PKCS#7) format
-
-    Args:
-        cert_file: Input PEM certificate file
-        output_file: Output P7B file
-    """
-
-    # Check if OpenSSL is available
-    try:
-        subprocess.run(["openssl", "version"], capture_output=True, check=True)
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print("ERROR: OpenSSL not found!")
-        print("\nFor Windows, you can:")
-        print(
-            "1. Install OpenSSL from: https://slproweb.com/products/Win32OpenSSL.html"
-        )
-        print("2. Or use Git Bash which includes OpenSSL")
-        print("3. Or use WSL (Windows Subsystem for Linux)")
-        return False
-
-    # Check if input file exists
-    if not os.path.exists(cert_file):
-        print(f"ERROR: Certificate file not found: {cert_file}")
-        print(f"Current directory: {os.getcwd()}")
-        print("\nMake sure you've generated the certificate first:")
-        print("  python generate_cert.py")
-        return False
-
-    print(f"Converting {cert_file} to P7B format...")
-
-    # Convert PEM to P7B (PKCS#7)
-    # -certfile can include intermediate certificates if needed
-    cmd = [
-        "openssl",
-        "crl2pkcs7",
-        "-nocrl",
-        "-certfile",
-        cert_file,
-        "-out",
-        output_file,
-    ]
-
-    try:
-        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
-
-        if os.path.exists(output_file):
-            print(f"\n✓ P7B certificate created: {os.path.abspath(output_file)}")
-            print(f"  File size: {os.path.getsize(output_file)} bytes")
-
-            print("\n" + "=" * 60)
-            print("Square Webhook Configuration:")
-            print("=" * 60)
-            print(f"1. Upload this file to Square Developer Dashboard:")
-            print(f"   {os.path.abspath(output_file)}")
-            print("\n2. In Square Dashboard:")
-            print("   - Go to Webhooks settings")
-            print("   - Click 'Manage Notification Settings'")
-            print("   - Upload the P7B file for signature verification")
-            print("\n3. Square will use this to verify webhook signatures")
-            print("=" * 60)
-
-            # Show file contents preview
-            print("\nP7B file preview (first 500 chars):")
-            with open(output_file, "r") as f:
-                content = f.read(500)
-                print(content)
-                if len(content) == 500:
-                    print("...")
-
-            return True
-        else:
-            print("ERROR: Output file was not created")
-            return False
-
-    except subprocess.CalledProcessError as e:
-        print(f"ERROR: Conversion failed: {e}")
-        if e.stderr:
-            print(f"OpenSSL error: {e.stderr}")
-        return False
-
-
-def convert_with_chain(cert_file="cert.pem", chain_file=None, output_file="cert.p7b"):
-    """
-    Convert PEM certificate with certificate chain to P7B format
-    Use this if you have intermediate certificates
-
-    Args:
-        cert_file: Your certificate file
-        chain_file: Intermediate/chain certificate file (optional)
-        output_file: Output P7B file
-    """
-
-    if not chain_file:
-        return convert_pem_to_p7b(cert_file, output_file)
-
-    # Check files exist
-    for f in [cert_file, chain_file]:
-        if not os.path.exists(f):
-            print(f"ERROR: File not found: {f}")
-            return False
-
-    print(f"Converting {cert_file} with chain {chain_file} to P7B format...")
-
-    # Create combined cert file
-    combined = "combined_cert.pem"
-    with open(combined, "w") as out:
-        with open(cert_file, "r") as f:
-            out.write(f.read())
-        with open(chain_file, "r") as f:
-            out.write(f.read())
-
-    result = convert_pem_to_p7b(combined, output_file)
-
-    # Clean up combined file
-    if os.path.exists(combined):
-        os.remove(combined)
-
-    return result
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Convert PEM certificate to P7B (PKCS#7) for Square webhooks"
-    )
-    parser.add_argument(
-        "--cert",
-        default="cert.pem",
-        help="Input PEM certificate file (default: cert.pem)",
-    )
-    parser.add_argument(
-        "--chain", default=None, help="Optional: Intermediate certificate chain file"
-    )
-    parser.add_argument(
-        "--output", default="cert.p7b", help="Output P7B file (default: cert.p7b)"
-    )
-
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("PEM to P7B Certificate Converter for Square Webhooks")
-    print("=" * 60)
-    print()
-
-    if args.chain:
-        success = convert_with_chain(args.cert, args.chain, args.output)
-    else:
-        success = convert_pem_to_p7b(args.cert, args.output)
-
-    if not success:
-        sys.exit(1)
-
-    print("\n✓ Conversion complete!")

src/scripts/generate_cert.py

@@ -1,76 +0,0 @@
-"""
-Generate self-signed SSL certificate for testing HTTPS webhooks
-Run this script to create cert.pem and key.pem files
-"""
-
-import subprocess
-import sys
-import os
-
-
-def generate_certificate():
-    """Generate self-signed certificate using OpenSSL"""
-
-    cert_file = "cert.pem"
-    key_file = "key.pem"
-
-    # Check if OpenSSL is available
-    try:
-        subprocess.run(["openssl", "version"], capture_output=True, check=True)
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print("ERROR: OpenSSL not found!")
-        print("\nFor Windows, you can:")
-        print(
-            "1. Install OpenSSL from: https://slproweb.com/products/Win32OpenSSL.html"
-        )
-        print("2. Or use Git Bash which includes OpenSSL")
-        print("3. Or use WSL (Windows Subsystem for Linux)")
-        return False
-
-    print("Generating self-signed certificate...")
-    print("This will create cert.pem and key.pem files")
-    print()
-
-    # Generate certificate valid for 365 days
-    cmd = [
-        "openssl",
-        "req",
-        "-x509",
-        "-newkey",
-        "rsa:4096",
-        "-keyout",
-        key_file,
-        "-out",
-        cert_file,
-        "-days",
-        "365",
-        "-nodes",  # No passphrase
-        "-subj",
-        "/C=US/ST=State/L=City/O=Organization/CN=localhost",
-    ]
-
-    try:
-        subprocess.run(cmd, check=True)
-        print(f"\n✓ Certificate created: {os.path.abspath(cert_file)}")
-        print(f"✓ Private key created: {os.path.abspath(key_file)}")
-        print("\nYou can now run the server with HTTPS:")
-        print(
-            f"  python src/test_server.py --ssl-cert {cert_file} --ssl-key {key_file} --hook-port 8443"
-        )
-        print("\nOr webhook-only HTTPS:")
-        print(
-            f"  python src/test_server.py --ssl-cert {cert_file} --ssl-key {key_file} --hook-port 8443 --hook-ssl-only"
-        )
-        print(
-            "\nNote: Self-signed certificates will show security warnings in browsers."
-        )
-        print("For production, use certificates from a trusted CA like Let's Encrypt.")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"ERROR: Failed to generate certificate: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    if not generate_certificate():
-        sys.exit(1)

src/server.py

@@ -74,7 +74,7 @@ async def handle_post(request):
                     return True
         else:
             return aiohttp.web.Response(status=400, text="400 Bad Request.")
-        result = {"message": f"studspider/0.1 received command: {reqdata}"}
+        result = {"message": f"Edderkop/0.1 received command: {reqdata}"}
         return aiohttp.web.json_response(status=200, data=result)
 
 
@@ -108,6 +108,6 @@ async def main():
 
 
 if __name__ == "__main__":
-    print(generate_toilet_banner("studspider v0.1"))
+    print(generate_toilet_banner("Edderkop v0.1"))
     print("Built for PLAY-WELL TEKNOLOGIES by contact@traps.moe\n\n")
     aiohttp.web.run_app(app, port=7432)

src/status/requirements.txt

@@ -0,0 +1,2 @@
+
+reflex==0.8.14.post1

src/status/rxconfig.py

@@ -0,0 +1,9 @@
+import reflex as rx
+
+config = rx.Config(
+    app_name="web",
+    plugins=[
+        rx.plugins.SitemapPlugin(),
+        rx.plugins.TailwindV4Plugin(),
+    ]
+)

src/status/web/web.py

@@ -0,0 +1,36 @@
+"""Welcome to Reflex! This file outlines the steps to create a basic app."""
+
+import reflex as rx
+
+from rxconfig import config
+
+
+class State(rx.State):
+    """The app state."""
+
+
+def index() -> rx.Component:
+    # Welcome Page (Index)
+    return rx.container(
+        rx.color_mode.button(position="top-right"),
+        rx.vstack(
+            rx.heading("Welcome to Reflex!", size="9"),
+            rx.text(
+                "Get started by editing ",
+                rx.code(f"{config.app_name}/{config.app_name}.py"),
+                size="5",
+            ),
+            rx.link(
+                rx.button("Check out our docs!"),
+                href="https://reflex.dev/docs/getting-started/introduction/",
+                is_external=True,
+            ),
+            spacing="5",
+            justify="center",
+            min_height="85vh",
+        ),
+    )
+
+
+app = rx.App()
+app.add_page(index)

src/test_server.py

@@ -1,7 +1,5 @@
-import argparse
 import asyncio
 import json
-import ssl
 from aiohttp import web
 from base64 import b64decode
 from typing import Dict, Any
@@ -9,16 +7,16 @@ import uuid
 
 import dotenv
 import os
-
 import re
 import logging
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
+print("Creating log directory if it doesn't exist...")
+os.makedirs("./logs/", exist_ok=True)
 
 import banner
 import get_sq_env
 from time import time
-
 time = int(time())
 import asquare as sq
 
@@ -33,15 +31,15 @@ from asyncio_throttle.throttler import Throttler
 
 # set up logger
 print("Setting up logger...")
-logger = logging.getLogger("studspider")
+logger = logging.getLogger("edderkop")
 logger.setLevel(logging.DEBUG)
-handler = RotatingFileHandler("./logs/studspider.log", maxBytes=125000, backupCount=5)
+handler = RotatingFileHandler("./logs/edderkop.log", maxBytes=125000, backupCount=5)
 logger.addHandler(handler)
 
 lego = AsyncBricksetAPI(debug=True, logger=logger)
 # sq = AsyncSquareClient(logger=logger)
 # logging.basicConfig(
-#    filename="./logs/studspider.log", encoding="utf-8", level=logging.DEBUG
+#    filename="./logs/edderkop.log", encoding="utf-8", level=logging.DEBUG
 # )
 print("Setting up rate limiter...")
 print("Doing RE things...")
@@ -50,9 +48,9 @@ UA = re.compile(r"^kopling\/?", re.IGNORECASE)
 
 async def run_update():
     set_list = await sq.acat2id(SQUARE_LEGO_CAT_ID) # type: ignore
-    # print(f"[@DEBUG]\t {set_list}")  # type: ignore
+    #print(f"[@DEBUG]\t {set_list}")  # type: ignore
     for l_set in set_list:
-        # print(f"[@DEBUG]{l_set}")
+        #print(f"[@DEBUG]{l_set}")
         try:
             l_setinfo = await lego.throttled_get_set(l_set["number"])
             print(f"[@DEBUG] Found {l_setinfo["pw_name"]}")
@@ -60,8 +58,8 @@ async def run_update():
             print(f"Error fetching set\t: {l_set}: {str(e)}")
             continue
 
-        # print(f"[@DEBUG]{l_setinfo}")
+        #print(f"[@DEBUG]{l_setinfo}")
-        # await sq.update_itm(l_set, l_setinfo)
+        #await sq.update_itm(l_set, l_setinfo)
     """for l_set in set_list:
         print(f"[@DEBUG]{l_set}")
         try:
@@ -82,89 +80,14 @@ def valid_uuid(val):
         return False
 
 
-async def hook_handler(request: web.Request) -> web.Response:
-    """Handle incoming JSON webhook POSTs on /hook endpoint"""
-    try:
-        current_time = int(asyncio.get_event_loop().time())
-
-        # Verify request method
-        if request.method != "POST":
-            logger.error(
-                f"{current_time}\tInvalid request method to /hook from %s",
-                request.remote,
-            )
-            return web.Response(status=405, text="Method not allowed. Use POST.")
-
-        # Get JSON data from request
-        try:
-            data = await request.json()
-        except json.JSONDecodeError as e:
-            print(f"[@DEBUG] Invalid JSON to /hook from {request.remote}: {str(e)}")
-            logger.error(f"Invalid JSON to /hook from {request.remote}: {str(e)}")
-            return web.Response(status=400, text="Invalid JSON in request body")
-
-        # Log the received webhook with detailed output
-        print(f"\n{'='*60}")
-        print(f"[@DEBUG] WEBHOOK RECEIVED at {current_time}")
-        print(f"[@DEBUG] From: {request.remote}")
-        print(f"[@DEBUG] Headers: {dict(request.headers)}")
-        print(f"[@DEBUG] Data type: {data.get('type', 'unknown')}")
-        print(f"[@DEBUG] Event ID: {data.get('event_id', 'none')}")
-        print(f"[@DEBUG] Full payload:")
-        print(json.dumps(data, indent=2))
-        print(f"{'='*60}\n")
-
-        logger.info(
-            f"{current_time}\tWebhook received from {request.remote}: {json.dumps(data)}"
-        )
-
-        # Process the webhook data here
-        # TODO: Add your webhook processing logic
-        webhook_type = data.get("type", "unknown")
-
-        if webhook_type == "inventory.count.updated":
-            print(f"[@DEBUG] Processing inventory count update...")
-            # Extract inventory data
-            inventory_counts = (
-                data.get("data", {}).get("object", {}).get("inventory_counts", [])
-            )
-            for count in inventory_counts:
-                print(f"[@DEBUG]   Catalog Object: {count.get('catalog_object_id')}")
-                print(f"[@DEBUG]   Quantity: {count.get('quantity')}")
-                print(f"[@DEBUG]   State: {count.get('state')}")
-
-        response_data = {
-            "status": "success",
-            "message": f"Webhook received: {webhook_type}",
-            "timestamp": current_time,
-            "event_id": data.get("event_id"),
-            "data_received": data,
-        }
-
-        return web.json_response(response_data)
-
-    except json.JSONDecodeError as e:
-        error_msg = f"JSON decode error in webhook: {str(e)}"
-        print(f"[@DEBUG] {error_msg}")
-        logger.error(error_msg)
-        return web.Response(status=400, text=error_msg)
-    except Exception as e:
-        error_msg = f"Webhook handler error: {str(e)}"
-        print(f"[@DEBUG] {error_msg}")
-        print(f"[@DEBUG] Exception type: {type(e).__name__}")
-        import traceback
-
-        print(f"[@DEBUG] Traceback:\n{traceback.format_exc()}")
-        logger.error(f"{error_msg}\n{traceback.format_exc()}")
-        return web.Response(status=500, text="Internal server error")
-
-
 async def request_handler(request: web.Request) -> web.Response:
     """Handle incoming POST requests with command processing"""
     try:
         # Verify request method
         if request.method != "POST":
-            logger.error(f"{time}\tInvalid request method from %s at ", request.remote)
+            logger.error(
+                f"{time}\tInvalid request method from %s at ", request.remote
+            )
             return web.Response(status=405, text="Method not allowed. Use POST.")
 
         # Get JSON data from request
@@ -202,7 +125,7 @@ async def request_handler(request: web.Request) -> web.Response:
             if decoded_cmd == "RUNUPDATE":
                 response_data = {"status": "success", "message": "Update started"}
                 await run_update()
-                logging.info(f"{time}\tUpdate command processed successfully")
+                logging.info(f"{time()}\tUpdate command processed successfully")
                 return web.json_response(response_data)
             else:
                 return web.Response(status=400, text=f"Unknown command: {decoded_cmd}")
@@ -215,186 +138,12 @@ async def request_handler(request: web.Request) -> web.Response:
         print(f"Request handler error: {str(e)}")
         return web.Response(status=500, text="Internal server error")
 
-
 print("Starting web server...")
-os.system("cls" if os.name == "nt" else "clear")
+os.system('cls' if os.name == 'nt' else 'clear')
 app = web.Application()
-app.router.add_post("/api", request_handler)
+app.router.add_post("/", request_handler)
-app.router.add_post("/hook", hook_handler)
-
-parser = argparse.ArgumentParser(
-    description="studspider - LEGO Inventory Sync Service for Square POS and Brickset",
-    epilog="""
-Examples:
-  # Basic HTTP server (recommended with nginx reverse proxy)
-  python src/test_server.py --host 0.0.0.0 --port 7432
-
-  # With separate webhook port
-  python src/test_server.py --port 7432 --hook-port 8080
-
-  # HTTPS using certificates from .env (set SSL_CERT_PATH and SSL_KEY_PATH)
-  python src/test_server.py --hook-port 8443 --hook-ssl-only
-
-  # HTTPS with command line override (self-signed cert for testing)
-  python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only
-
-  # Full HTTPS (both endpoints)
-  python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443
-
-  # Production behind nginx (no SSL needed in app)
-  python src/test_server.py --host 127.0.0.1 --port 7432
-
-Environment Variables (.env):
-  SSL_CERT_PATH       - Default SSL certificate path
-  SSL_KEY_PATH        - Default SSL key path  
-  SQUARE_P7B_PATH     - P7B file to upload to Square Dashboard
-
-For more information, see doc/ 
-    """,
-    formatter_class=argparse.RawDescriptionHelpFormatter,
-)
-parser.add_argument(
-    "--host",
-    type=str,
-    default="localhost",
-    help="IP address to listen on (default: localhost, use 0.0.0.0 for all interfaces)",
-)
-parser.add_argument(
-    "--port", type=int, default=7432, help="Port for main API endpoint (default: 7432)"
-)
-parser.add_argument(
-    "--hook-port",
-    type=int,
-    default=None,
-    help="Separate port for webhook endpoint (default: None - uses same port as --port)",
-)
-parser.add_argument(
-    "--ssl-cert",
-    type=str,
-    default=get_sq_env.SSL_CERT_PATH,
-    help="Path to SSL certificate file in PEM format (default: from .env SSL_CERT_PATH)",
-)
-parser.add_argument(
-    "--ssl-key",
-    type=str,
-    default=get_sq_env.SSL_KEY_PATH,
-    help="Path to SSL private key file in PEM format (default: from .env SSL_KEY_PATH)",
-)
-parser.add_argument(
-    "--hook-ssl-only",
-    action="store_true",
-    help="Enable HTTPS only for webhook endpoint, main API stays HTTP (requires --ssl-cert and --ssl-key)",
-)
-args = parser.parse_args()
 
 if __name__ == "__main__":
-    print("Creating log directory if it doesn't exist...")
+    print(banner.generate("Edderkop v0.1"))
-    os.makedirs("./logs/", exist_ok=True)
+    print("Built for PLAY-WELL TEKNOLOGIES by contact@traps.moe\n\n")
-    print(banner.generate("studspider v0.1"))
+    web.run_app(app, host="localhost", port=7432)
-    print("Built for PLAY-WELL TEKNOLOGIES by contact@studspider.sh\n\n")
-
-    # Setup SSL context if certificates provided
-    ssl_context = None
-    if args.ssl_cert and args.ssl_key:
-        # Check if trying to use P7B file
-        if args.ssl_cert.endswith(".p7b") or args.ssl_key.endswith(".p7b"):
-            print("ERROR: Cannot use P7B files directly for HTTPS server!")
-            print("\nP7B files are for Square's webhook signature verification only.")
-            print("Your server needs PEM format files (.pem)")
-            print("\nWorkflow:")
-            print("1. Generate PEM files: python generate_cert.py")
-            print("2. Convert to P7B for Square: python convert_to_p7b.py")
-            print("3. Upload P7B to Square Dashboard")
-            print("4. Run server with PEM files:")
-            print(
-                "   python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443"
-            )
-            print("\nIf you have a P7B and need PEM:")
-            print("   python convert_from_p7b.py your_cert.p7b")
-            exit(1)
-
-        try:
-            ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-            ssl_context.load_cert_chain(args.ssl_cert, args.ssl_key)
-            print(f"✓ SSL enabled with cert: {args.ssl_cert}")
-
-            # Show P7B info if configured
-            if get_sq_env.SQUARE_P7B_PATH:
-                print(
-                    f"ℹ️  Square P7B certificate for upload: {get_sq_env.SQUARE_P7B_PATH}"
-                )
-                if os.path.exists(get_sq_env.SQUARE_P7B_PATH):
-                    print(f"   ✓ P7B file exists")
-                else:
-                    print(f"   ⚠️  P7B file not found - run: python convert_to_p7b.py")
-        except FileNotFoundError as e:
-            print(f"ERROR: Certificate file not found: {e}")
-            exit(1)
-        except ssl.SSLError as e:
-            print(f"ERROR: Invalid certificate or key file: {e}")
-            print("\nMake sure you're using PEM format files.")
-            print("Generate certificates with: python generate_cert.py")
-            exit(1)
-    elif args.ssl_cert or args.ssl_key:
-        print("ERROR: Both --ssl-cert and --ssl-key must be provided together")
-        exit(1)
-    else:
-        print("ℹ️  Running without SSL (HTTP only)")
-        print("   For production with nginx reverse proxy, this is recommended.")
-        print("   Nginx will handle HTTPS, forward HTTP to this server.")
-
-        # Show P7B info even without SSL (for nginx setup)
-        if get_sq_env.SQUARE_P7B_PATH:
-            print(
-                f"\nℹ️  Square P7B certificate configured: {get_sq_env.SQUARE_P7B_PATH}"
-            )
-            if os.path.exists(get_sq_env.SQUARE_P7B_PATH):
-                print(f"   ✓ P7B file exists - upload this to Square Dashboard")
-                print(f"   Square Dashboard → Webhooks → Manage Notification Settings")
-            else:
-                print(f"   ⚠️  P7B file not found")
-                print(
-                    f"   Generate with: python convert_to_p7b.py --cert /path/to/nginx/cert.pem"
-                )
-
-    # If hook-port is specified, run a separate server for webhooks
-    if args.hook_port:
-        protocol_main = "https" if (ssl_context and not args.hook_ssl_only) else "http"
-        protocol_hook = "https" if ssl_context else "http"
-
-        # Create separate app for webhook
-        hook_app = web.Application()
-        hook_app.router.add_post("/hook", hook_handler)
-
-        # Run both servers concurrently
-        async def run_servers():
-            runner1 = web.AppRunner(app)
-            await runner1.setup()
-            # Main server uses SSL only if not hook-ssl-only mode
-            main_ssl = None if args.hook_ssl_only else ssl_context
-            site1 = web.TCPSite(runner1, args.host, args.port, ssl_context=main_ssl)
-
-            runner2 = web.AppRunner(hook_app)
-            await runner2.setup()
-            # Webhook server always uses SSL if certificates provided
-            site2 = web.TCPSite(
-                runner2, args.host, args.hook_port, ssl_context=ssl_context
-            )
-
-            await site1.start()
-            await site2.start()
-
-            print(f"Starting main server on {args.host}:{args.port} ({protocol_main})")
-            print(
-                f"Starting webhook server on {args.host}:{args.hook_port} ({protocol_hook})"
-            )
-
-            # Keep running
-            await asyncio.Event().wait()
-
-        asyncio.run(run_servers())
-    else:
-        protocol = "https" if ssl_context else "http"
-        print(f"Server running on {args.host}:{args.port} ({protocol})")
-        print(f"Webhook endpoint: {protocol}://{args.host}:{args.port}/hook")
-        web.run_app(app, host=args.host, port=args.port, ssl_context=ssl_context)

src/test_webhook.py

@@ -1,102 +0,0 @@
-"""
-Test script for webhook endpoint
-Sends the Square inventory.count.updated webhook payload
-"""
-
-import asyncio
-import aiohttp
-import json
-import ssl
-import sys
-
-
-async def test_webhook(verify_ssl=True):
-    url = "https://studspider.sh:8443/hook"
-
-    # Your Square webhook payload
-    payload = {
-        "merchant_id": "6SSW7HV8K2ST5",
-        "type": "inventory.count.updated",
-        "event_id": "df5f3813-a913-45a1-94e9-fdc3f7d5e3b6",
-        "created_at": "2019-10-29T18:38:45.455006797Z",
-        "data": {
-            "type": "inventory_counts",
-            "id": "84e4ac73-d605-4dbd-a9e5-ffff794ddb9d",
-            "object": {
-                "inventory_counts": [
-                    {
-                        "calculated_at": "2019-10-29T18:38:45.10296Z",
-                        "catalog_object_id": "FGQ5JJWT2PYTHF35CKZ2DSKP",
-                        "catalog_object_type": "ITEM_VARIATION",
-                        "location_id": "YYQR03DGCTXA4",
-                        "quantity": "10",
-                        "state": "IN_STOCK",
-                    }
-                ]
-            },
-        },
-    }
-
-    print("Sending webhook test payload...")
-    print(f"URL: {url}")
-    print(
-        f"SSL Verification: {'Enabled' if verify_ssl else 'Disabled (accepting self-signed certs)'}"
-    )
-    print(json.dumps(payload, indent=2))
-    print("\n" + "=" * 60 + "\n")
-
-    # Create SSL context that allows self-signed certificates if verify_ssl is False
-    ssl_context = None
-    if not verify_ssl:
-        ssl_context = ssl.create_default_context()
-        ssl_context.check_hostname = False
-        ssl_context.verify_mode = ssl.CERT_NONE
-
-    try:
-        connector = aiohttp.TCPConnector(ssl=ssl_context)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post(url, json=payload) as resp:
-                print(f"Status: {resp.status}")
-                print(f"Response headers: {dict(resp.headers)}")
-
-                response_text = await resp.text()
-                print(f"\nResponse body:")
-
-                try:
-                    response_json = json.loads(response_text)
-                    print(json.dumps(response_json, indent=2))
-                except json.JSONDecodeError:
-                    print(response_text)
-
-    except aiohttp.ClientConnectorError as e:
-        print(f"Connection error: {e}")
-        print("\nTroubleshooting:")
-        print("1. Make sure the server is running")
-        print("2. Check if the hostname and port are correct")
-        print("3. For self-signed certificates, the script now accepts them by default")
-        print("\nServer start command:")
-        print(
-            "  python src/test_server.py --ssl-cert cert.pem --ssl-key key.pem --hook-port 8443 --hook-ssl-only"
-        )
-    except aiohttp.ServerTimeoutError as e:
-        print(f"Timeout error: {e}")
-        print("The server took too long to respond")
-    except Exception as e:
-        print(f"Error: {type(e).__name__}: {e}")
-
-
-if __name__ == "__main__":
-    # Check command line arguments
-    verify_ssl = True
-    if len(sys.argv) > 1 and sys.argv[1] in ["--no-verify", "--insecure", "-k"]:
-        verify_ssl = False
-        print("⚠️  SSL verification disabled - accepting self-signed certificates\n")
-    elif len(sys.argv) > 1:
-        print("Usage: python src/test_webhook.py [--no-verify]")
-        print(
-            "  --no-verify: Disable SSL certificate verification (for self-signed certs)"
-        )
-        sys.exit(1)
-
-    # Default to no verification since we're likely using self-signed certs
-    asyncio.run(test_webhook(verify_ssl=False))

uv.lock

@@ -239,6 +239,39 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" },
 ]
 
+[[package]]
+name = "edderkop"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "aiosqlite" },
+    { name = "apscheduler" },
+    { name = "asyncio-throttle" },
+    { name = "bs4" },
+    { name = "dotenv" },
+    { name = "pyinstaller" },
+    { name = "pytest" },
+    { name = "reflex" },
+    { name = "requests" },
+    { name = "squareup" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "aiohttp", specifier = ">=3.12.13,<4.0.0" },
+    { name = "aiosqlite", specifier = ">=0.21.0,<0.22.0" },
+    { name = "apscheduler", specifier = ">=3.11.0,<4.0.0" },
+    { name = "asyncio-throttle", specifier = ">=1.0.2,<2.0.0" },
+    { name = "bs4", specifier = ">=0.0.2" },
+    { name = "dotenv", specifier = ">=0.9.9,<0.10.0" },
+    { name = "pyinstaller", specifier = ">=6.14.1,<7.0.0" },
+    { name = "pytest", specifier = ">=8.4.2,<9.0.0" },
+    { name = "reflex", specifier = ">=0.8.14.post1" },
+    { name = "requests", specifier = ">=2.32.4,<3.0.0" },
+    { name = "squareup", specifier = ">=43.0.0.20250618,<44.0.0.0" },
+]
+
 [[package]]
 name = "frozenlist"
 version = "1.7.0"
@@ -938,39 +971,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
 ]
 
-[[package]]
-name = "studpider"
-version = "0.1.0"
-source = { virtual = "." }
-dependencies = [
-    { name = "aiohttp" },
-    { name = "aiosqlite" },
-    { name = "apscheduler" },
-    { name = "asyncio-throttle" },
-    { name = "bs4" },
-    { name = "dotenv" },
-    { name = "pyinstaller" },
-    { name = "pytest" },
-    { name = "reflex" },
-    { name = "requests" },
-    { name = "squareup" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "aiohttp", specifier = ">=3.12.13,<4.0.0" },
-    { name = "aiosqlite", specifier = ">=0.21.0,<0.22.0" },
-    { name = "apscheduler", specifier = ">=3.11.0,<4.0.0" },
-    { name = "asyncio-throttle", specifier = ">=1.0.2,<2.0.0" },
-    { name = "bs4", specifier = ">=0.0.2" },
-    { name = "dotenv", specifier = ">=0.9.9,<0.10.0" },
-    { name = "pyinstaller", specifier = ">=6.14.1,<7.0.0" },
-    { name = "pytest", specifier = ">=8.4.2,<9.0.0" },
-    { name = "reflex", specifier = ">=0.8.14.post1" },
-    { name = "requests", specifier = ">=2.32.4,<3.0.0" },
-    { name = "squareup", specifier = ">=43.0.0.20250618,<44.0.0.0" },
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"