diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 00000000..80bdacbe --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,9 @@ +{ + "permissions": { + "allow": [ + "Bash(python -m archivebox:*)", + "Bash(ls:*)", + "Bash(xargs:*)" + ] + } +} diff --git a/ArchiveBox.conf b/ArchiveBox.conf new file mode 100644 index 00000000..a7eaff41 --- /dev/null +++ b/ArchiveBox.conf @@ -0,0 +1,3 @@ +[SERVER_CONFIG] +SECRET_KEY = y6fw9wcaqls9sx_dze6ahky9ggpkpzoaw5g5v98_u3ro5j0_4f + diff --git a/PLUGIN_ENHANCEMENTS.md b/PLUGIN_ENHANCEMENTS.md new file mode 100644 index 00000000..ade53064 --- /dev/null +++ b/PLUGIN_ENHANCEMENTS.md @@ -0,0 +1,300 @@ +# JS Implementation Features to Port to Python ArchiveBox + +## Priority: High Impact Features + +### 1. **Screen Recording** ⭐⭐⭐ +**JS Implementation:** Captures MP4 video + animated GIF of the archiving session +```javascript +// Records browser activity including scrolling, interactions +PuppeteerScreenRecorder → screenrecording.mp4 +ffmpeg conversion → screenrecording.gif (first 10s, optimized) +``` + +**Enhancement for Python:** +- Add `on_Snapshot__24_screenrecording.py` +- Use puppeteer or playwright screen recording APIs +- Generate both full MP4 and thumbnail GIF +- **Value:** Visual proof of what was captured, useful for QA and debugging + +### 2. **AI Quality Assurance** ⭐⭐⭐ +**JS Implementation:** Uses GPT-4o to analyze screenshots and validate archive quality +```javascript +// ai_qa.py analyzes screenshot.png and returns: +{ + "pct_visible": 85, + "warnings": ["Some content may be cut off"], + "main_content_title": "Article Title", + "main_content_author": "Author Name", + "main_content_date": "2024-01-15", + "website_brand_name": "Example.com" +} +``` + +**Enhancement for Python:** +- Add `on_Snapshot__95_aiqa.py` (runs after screenshot) +- Integrate with OpenAI API or local vision models +- Validates: content visibility, broken layouts, CAPTCHA blocks, error pages +- **Value:** Automatic detection of failed archives, quality scoring + +### 3. **Network Response Archiving** ⭐⭐⭐ +**JS Implementation:** Saves ALL network responses in organized structure +``` +responses/ +├── all/ # Timestamped unique files +│ ├── 20240101120000__GET__https%3A%2F%2Fexample.com%2Fapi.json +│ └── ... +├── script/ # Organized by resource type +│ └── example.com/path/to/script.js → ../all/... +├── stylesheet/ +├── image/ +├── media/ +└── index.jsonl # Searchable index +``` + +**Enhancement for Python:** +- Add `on_Snapshot__23_responses.py` +- Save all HTTP responses (XHR, images, scripts, etc.) +- Create both timestamped and URL-organized views via symlinks +- Generate `index.jsonl` with metadata (URL, method, status, mimeType, sha256) +- **Value:** Complete HTTP-level archive, better debugging, API response preservation + +### 4. **Detailed Metadata Extractors** ⭐⭐ + +#### 4a. SSL/TLS Details (`on_Snapshot__16_ssl.py`) +```python +{ + "protocol": "TLS 1.3", + "cipher": "AES_128_GCM", + "securityState": "secure", + "securityDetails": { + "issuer": "Let's Encrypt", + "validFrom": ..., + "validTo": ... + } +} +``` + +#### 4b. SEO Metadata (`on_Snapshot__17_seo.py`) +Extracts all `` tags: +```python +{ + "og:title": "Page Title", + "og:image": "https://example.com/image.jpg", + "twitter:card": "summary_large_image", + "description": "Page description", + ... +} +``` + +#### 4c. Accessibility Tree (`on_Snapshot__18_accessibility.py`) +```python +{ + "headings": ["# Main Title", "## Section 1", ...], + "iframes": ["https://embed.example.com/..."], + "tree": { ... } # Full accessibility snapshot +} +``` + +#### 4d. Outlinks Categorization (`on_Snapshot__19_outlinks.py`) +Better than current implementation - categorizes by type: +```python +{ + "hrefs": [...], # All links + "images": [...], # + "css_stylesheets": [...], # + "js_scripts": [...], # ', '', html, flags=re.DOTALL | re.IGNORECASE) + text = re.sub(r']*>.*?', '', text, flags=re.DOTALL | re.IGNORECASE) + text = re.sub(r'<[^>]+>', ' ', text) + text = re.sub(r'\s+', ' ', text) + return text.strip() + + +def find_html_source() -> str | None: + """Find HTML content from other extractors in the snapshot directory.""" + # Hooks run in snapshot_dir, sibling extractor outputs are in subdirectories + search_patterns = [ + 'singlefile/singlefile.html', + 'singlefile/*.html', + 'dom/output.html', + 'dom/*.html', + 'wget/**/*.html', + 'wget/**/*.htm', + ] + + cwd = Path.cwd() + for pattern in search_patterns: + matches = list(cwd.glob(pattern)) + for match in matches: + if match.is_file() and match.stat().st_size > 0: + try: + return match.read_text(errors='ignore') + except Exception: + continue + + return None + + +def extract_htmltotext(url: str) -> tuple[bool, str | None, str]: + """ + Extract plain text from HTML sources. + + Returns: (success, output_path, error_message) + """ + # Find HTML source from other extractors + html_content = find_html_source() + if not html_content: + return False, None, 'No HTML source found (run singlefile, dom, or wget first)' + + # Convert HTML to text + text = html_to_text(html_content) + + if not text or len(text) < 10: + return False, None, 'No meaningful text extracted from HTML' + + # Create output directory and write output + output_dir = Path(OUTPUT_DIR) + output_dir.mkdir(exist_ok=True) + output_path = output_dir / OUTPUT_FILE + output_path.write_text(text, encoding='utf-8') + + return True, str(output_path), '' + + +@click.command() +@click.option('--url', required=True, help='URL that was archived') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Convert HTML to plain text for search indexing.""" + + start_ts = datetime.now(timezone.utc) + output = None + status = 'failed' + error = '' + + try: + # Run extraction + success, output, error = extract_htmltotext(url) + status = 'succeeded' if success else 'failed' + + if success: + text_len = Path(output).stat().st_size + print(f'Extracted {text_len} characters of text') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/istilldontcareaboutcookies/on_Snapshot__02_istilldontcareaboutcookies.js b/archivebox/plugins/istilldontcareaboutcookies/on_Snapshot__02_istilldontcareaboutcookies.js new file mode 100755 index 00000000..0f2672f5 --- /dev/null +++ b/archivebox/plugins/istilldontcareaboutcookies/on_Snapshot__02_istilldontcareaboutcookies.js @@ -0,0 +1,115 @@ +#!/usr/bin/env node +/** + * I Still Don't Care About Cookies Extension Plugin + * + * Installs and configures the "I still don't care about cookies" Chrome extension + * for automatic cookie consent banner dismissal during page archiving. + * + * Extension: https://chromewebstore.google.com/detail/edibdbjcniadpccecjdfdjjppcpchdlm + * + * Priority: 02 (early) - Must install before Chrome session starts + * Hook: on_Snapshot + * + * This extension automatically: + * - Dismisses cookie consent popups + * - Removes cookie banners + * - Accepts necessary cookies to proceed with browsing + * - Works on thousands of websites out of the box + */ + +const path = require('path'); +const fs = require('fs'); + +// Import extension utilities +const extensionUtils = require('../chrome_extensions/chrome_extension_utils.js'); + +// Extension metadata +const EXTENSION = { + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', +}; + +// Get extensions directory from environment or use default +const EXTENSIONS_DIR = process.env.CHROME_EXTENSIONS_DIR || + path.join(process.env.DATA_DIR || './data', 'personas', process.env.ACTIVE_PERSONA || 'Default', 'chrome_extensions'); + +/** + * Install the I Still Don't Care About Cookies extension + */ +async function installCookiesExtension() { + console.log('[*] Installing I Still Don\'t Care About Cookies extension...'); + + // Install the extension + const extension = await extensionUtils.loadOrInstallExtension(EXTENSION, EXTENSIONS_DIR); + + if (!extension) { + console.error('[❌] Failed to install I Still Don\'t Care About Cookies extension'); + return null; + } + + console.log('[+] I Still Don\'t Care About Cookies extension installed'); + console.log('[+] Cookie banners will be automatically dismissed during archiving'); + + return extension; +} + +/** + * Note: This extension works out of the box with no configuration needed. + * It automatically detects and dismisses cookie banners on page load. + */ + +/** + * Main entry point - install extension before archiving + */ +async function main() { + // Check if extension is already cached + const cacheFile = path.join(EXTENSIONS_DIR, 'istilldontcareaboutcookies.extension.json'); + + if (fs.existsSync(cacheFile)) { + try { + const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); + const manifestPath = path.join(cached.unpacked_path, 'manifest.json'); + + if (fs.existsSync(manifestPath)) { + console.log('[*] I Still Don\'t Care About Cookies extension already installed (using cache)'); + return cached; + } + } catch (e) { + // Cache file corrupted, re-install + console.warn('[⚠️] Extension cache corrupted, re-installing...'); + } + } + + // Install extension + const extension = await installCookiesExtension(); + + // Export extension metadata for chrome_session to load + if (extension) { + // Write extension info to a cache file that chrome_session can read + await fs.promises.mkdir(EXTENSIONS_DIR, { recursive: true }); + await fs.promises.writeFile( + cacheFile, + JSON.stringify(extension, null, 2) + ); + console.log(`[+] Extension metadata written to ${cacheFile}`); + } + + return extension; +} + +// Export functions for use by other plugins +module.exports = { + EXTENSION, + installCookiesExtension, +}; + +// Run if executed directly +if (require.main === module) { + main().then(() => { + console.log('[✓] I Still Don\'t Care About Cookies extension setup complete'); + process.exit(0); + }).catch(err => { + console.error('[❌] I Still Don\'t Care About Cookies extension setup failed:', err); + process.exit(1); + }); +} diff --git a/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.js b/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.js new file mode 100644 index 00000000..f2a6e943 --- /dev/null +++ b/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.js @@ -0,0 +1,279 @@ +/** + * Unit tests for istilldontcareaboutcookies plugin + * + * Run with: node --test tests/test_istilldontcareaboutcookies.js + */ + +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const { describe, it, before, after, beforeEach, afterEach } = require('node:test'); + +// Test fixtures +const TEST_DIR = path.join(__dirname, '.test_fixtures'); +const TEST_EXTENSIONS_DIR = path.join(TEST_DIR, 'chrome_extensions'); + +describe('istilldontcareaboutcookies plugin', () => { + before(() => { + if (!fs.existsSync(TEST_DIR)) { + fs.mkdirSync(TEST_DIR, { recursive: true }); + } + }); + + after(() => { + if (fs.existsSync(TEST_DIR)) { + fs.rmSync(TEST_DIR, { recursive: true, force: true }); + } + }); + + describe('EXTENSION metadata', () => { + it('should have correct webstore_id', () => { + const { EXTENSION } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + assert.strictEqual(EXTENSION.webstore_id, 'edibdbjcniadpccecjdfdjjppcpchdlm'); + }); + + it('should have correct name', () => { + const { EXTENSION } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + assert.strictEqual(EXTENSION.name, 'istilldontcareaboutcookies'); + }); + }); + + describe('installCookiesExtension', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should use cached extension if available', async () => { + const { installCookiesExtension } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + // Create fake cache + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'istilldontcareaboutcookies.extension.json'); + const fakeExtensionDir = path.join(TEST_EXTENSIONS_DIR, 'fake_cookies'); + + fs.mkdirSync(fakeExtensionDir, { recursive: true }); + fs.writeFileSync( + path.join(fakeExtensionDir, 'manifest.json'), + JSON.stringify({ version: '1.1.8' }) + ); + + const fakeCache = { + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', + unpacked_path: fakeExtensionDir, + version: '1.1.8' + }; + + fs.writeFileSync(cacheFile, JSON.stringify(fakeCache)); + + const result = await installCookiesExtension(); + + assert.notStrictEqual(result, null); + assert.strictEqual(result.webstore_id, 'edibdbjcniadpccecjdfdjjppcpchdlm'); + }); + + it('should not require any configuration', async () => { + // This extension works out of the box + // No API keys or config needed + const { EXTENSION } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + assert.ok(EXTENSION); + // No config fields should be required + }); + }); + + describe('cache file creation', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should create cache file with correct extension name', async () => { + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'istilldontcareaboutcookies.extension.json'); + + // Create mock extension + const mockExtension = { + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', + version: '1.1.9' + }; + + await fs.promises.writeFile(cacheFile, JSON.stringify(mockExtension, null, 2)); + + assert.ok(fs.existsSync(cacheFile)); + + const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); + assert.strictEqual(cache.name, 'istilldontcareaboutcookies'); + }); + + it('should use correct filename pattern', () => { + const expectedPattern = 'istilldontcareaboutcookies.extension.json'; + const cacheFile = path.join(TEST_EXTENSIONS_DIR, expectedPattern); + + // Pattern should match expected format + assert.ok(path.basename(cacheFile).endsWith('.extension.json')); + assert.ok(path.basename(cacheFile).includes('istilldontcareaboutcookies')); + }); + }); + + describe('extension functionality', () => { + it('should work automatically without configuration', () => { + // This extension automatically dismisses cookie banners + // No manual trigger or configuration needed + + const features = { + automaticBannerDismissal: true, + requiresConfiguration: false, + requiresApiKey: false, + requiresUserAction: false + }; + + assert.strictEqual(features.automaticBannerDismissal, true); + assert.strictEqual(features.requiresConfiguration, false); + assert.strictEqual(features.requiresApiKey, false); + assert.strictEqual(features.requiresUserAction, false); + }); + + it('should not require any runtime hooks', () => { + // Extension works purely via Chrome's content script injection + // No need for additional hooks or configuration + + const requiresHooks = { + preNavigation: false, + postNavigation: false, + onPageLoad: false + }; + + assert.strictEqual(requiresHooks.preNavigation, false); + assert.strictEqual(requiresHooks.postNavigation, false); + assert.strictEqual(requiresHooks.onPageLoad, false); + }); + }); + + describe('priority and execution order', () => { + it('should have priority 02 (early)', () => { + const filename = 'on_Snapshot__02_istilldontcareaboutcookies.js'; + + // Extract priority from filename + const match = filename.match(/on_Snapshot__(\d+)_/); + assert.ok(match); + + const priority = parseInt(match[1]); + assert.strictEqual(priority, 2); + }); + + it('should run before chrome_session (priority 20)', () => { + const extensionPriority = 2; + const chromeSessionPriority = 20; + + assert.ok(extensionPriority < chromeSessionPriority); + }); + }); + + describe('error handling', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should handle corrupted cache gracefully', async () => { + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'istilldontcareaboutcookies.extension.json'); + + // Create corrupted cache + fs.writeFileSync(cacheFile, 'invalid json content'); + + // Should detect corruption and proceed with fresh install + const { installCookiesExtension } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + // Mock loadOrInstallExtension to avoid actual download + const extensionUtils = require('../../chrome_extensions/chrome_extension_utils.js'); + const originalFunc = extensionUtils.loadOrInstallExtension; + + extensionUtils.loadOrInstallExtension = async () => ({ + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', + version: '1.1.9' + }); + + const result = await installCookiesExtension(); + + extensionUtils.loadOrInstallExtension = originalFunc; + + assert.notStrictEqual(result, null); + }); + + it('should handle missing manifest gracefully', async () => { + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'istilldontcareaboutcookies.extension.json'); + const fakeExtensionDir = path.join(TEST_EXTENSIONS_DIR, 'fake_cookies_no_manifest'); + + // Create directory without manifest + fs.mkdirSync(fakeExtensionDir, { recursive: true }); + + const fakeCache = { + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', + unpacked_path: fakeExtensionDir + }; + + fs.writeFileSync(cacheFile, JSON.stringify(fakeCache)); + + const { installCookiesExtension } = require('../on_Snapshot__02_istilldontcareaboutcookies.js'); + + // Mock to return fresh extension when manifest missing + const extensionUtils = require('../../chrome_extensions/chrome_extension_utils.js'); + const originalFunc = extensionUtils.loadOrInstallExtension; + + let freshInstallCalled = false; + extensionUtils.loadOrInstallExtension = async () => { + freshInstallCalled = true; + return { + webstore_id: 'edibdbjcniadpccecjdfdjjppcpchdlm', + name: 'istilldontcareaboutcookies', + version: '1.1.9' + }; + }; + + const result = await installCookiesExtension(); + + extensionUtils.loadOrInstallExtension = originalFunc; + + // Should trigger fresh install when manifest missing + assert.ok(freshInstallCalled || result); + }); + }); +}); diff --git a/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.py b/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.py new file mode 100644 index 00000000..aad86b55 --- /dev/null +++ b/archivebox/plugins/istilldontcareaboutcookies/tests/test_istilldontcareaboutcookies.py @@ -0,0 +1,122 @@ +""" +Unit tests for istilldontcareaboutcookies plugin + +Tests invoke the plugin hook as an external process and verify outputs/side effects. +""" + +import json +import os +import subprocess +import tempfile +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +INSTALL_SCRIPT = PLUGIN_DIR / "on_Snapshot__02_istilldontcareaboutcookies.js" + + +def test_install_script_exists(): + """Verify install script exists""" + assert INSTALL_SCRIPT.exists(), f"Install script not found: {INSTALL_SCRIPT}" + + +def test_extension_metadata(): + """Test that extension has correct metadata""" + with tempfile.TemporaryDirectory() as tmpdir: + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(Path(tmpdir) / "chrome_extensions") + + result = subprocess.run( + ["node", "-e", f"const ext = require('{INSTALL_SCRIPT}'); console.log(JSON.stringify(ext.EXTENSION))"], + capture_output=True, + text=True, + env=env + ) + + assert result.returncode == 0, f"Failed to load extension metadata: {result.stderr}" + + metadata = json.loads(result.stdout) + assert metadata["webstore_id"] == "edibdbjcniadpccecjdfdjjppcpchdlm" + assert metadata["name"] == "istilldontcareaboutcookies" + + +def test_install_creates_cache(): + """Test that install creates extension cache""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=60 + ) + + # Check output mentions installation + assert "Installing" in result.stdout or "installed" in result.stdout or "istilldontcareaboutcookies" in result.stdout + + # Check cache file was created + cache_file = ext_dir / "istilldontcareaboutcookies.extension.json" + assert cache_file.exists(), "Cache file should be created" + + # Verify cache content + cache_data = json.loads(cache_file.read_text()) + assert cache_data["webstore_id"] == "edibdbjcniadpccecjdfdjjppcpchdlm" + assert cache_data["name"] == "istilldontcareaboutcookies" + + +def test_install_uses_existing_cache(): + """Test that install uses existing cache when available""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + # Create fake cache + fake_extension_dir = ext_dir / "edibdbjcniadpccecjdfdjjppcpchdlm__istilldontcareaboutcookies" + fake_extension_dir.mkdir(parents=True) + + manifest = {"version": "1.1.8", "name": "I still don't care about cookies"} + (fake_extension_dir / "manifest.json").write_text(json.dumps(manifest)) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Should use cache or install successfully + assert result.returncode == 0 + + +def test_no_configuration_required(): + """Test that extension works without any configuration""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + # No special env vars needed - works out of the box + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=60 + ) + + # Should not require any API keys or configuration + assert "API" not in (result.stdout + result.stderr) or result.returncode == 0 diff --git a/archivebox/plugins/media/config.json b/archivebox/plugins/media/config.json new file mode 100644 index 00000000..cfaafba0 --- /dev/null +++ b/archivebox/plugins/media/config.json @@ -0,0 +1,55 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "additionalProperties": false, + "properties": { + "SAVE_MEDIA": { + "type": "boolean", + "default": true, + "x-aliases": ["USE_YTDLP", "FETCH_MEDIA"], + "description": "Enable media downloading with yt-dlp" + }, + "YOUTUBEDL_BINARY": { + "type": "string", + "default": "yt-dlp", + "x-aliases": ["YTDLP_BINARY", "YOUTUBE_DL_BINARY"], + "description": "Path to yt-dlp binary" + }, + "MEDIA_TIMEOUT": { + "type": "integer", + "default": 3600, + "minimum": 30, + "x-fallback": "TIMEOUT", + "description": "Timeout for media downloads in seconds" + }, + "MEDIA_MAX_SIZE": { + "type": "string", + "default": "750m", + "pattern": "^\\d+[kmgKMG]?$", + "description": "Maximum file size for media downloads" + }, + "YTDLP_CHECK_SSL_VALIDITY": { + "type": "boolean", + "default": true, + "x-fallback": "CHECK_SSL_VALIDITY", + "description": "Whether to verify SSL certificates" + }, + "YTDLP_ARGS": { + "type": "array", + "items": {"type": "string"}, + "default": [ + "--write-info-json", + "--write-thumbnail", + "--write-sub", + "--embed-subs", + "--write-auto-sub" + ], + "description": "Default yt-dlp arguments" + }, + "YTDLP_EXTRA_ARGS": { + "type": "string", + "default": "", + "description": "Extra arguments for yt-dlp (space-separated)" + } + } +} diff --git a/archivebox/plugins/media/on_Snapshot__51_media.py b/archivebox/plugins/media/on_Snapshot__51_media.py new file mode 100644 index 00000000..552f5258 --- /dev/null +++ b/archivebox/plugins/media/on_Snapshot__51_media.py @@ -0,0 +1,306 @@ +#!/usr/bin/env python3 +""" +Download media from a URL using yt-dlp. + +Usage: on_Snapshot__media.py --url= --snapshot-id= +Output: Downloads media files to $PWD/media/ + +Environment variables: + YTDLP_BINARY: Path to yt-dlp binary + YTDLP_TIMEOUT: Timeout in seconds (default: 3600 for large media) + YTDLP_CHECK_SSL_VALIDITY: Whether to check SSL certificates (default: True) + YTDLP_EXTRA_ARGS: Extra arguments for yt-dlp (space-separated) + + # Media feature toggles + USE_YTDLP: Enable yt-dlp media extraction (default: True) + SAVE_MEDIA: Alias for USE_YTDLP + + # Media size limits + MEDIA_MAX_SIZE: Maximum media file size (default: 750m) + + # Fallback to ARCHIVING_CONFIG values if YTDLP_* not set: + MEDIA_TIMEOUT: Fallback timeout for media + TIMEOUT: Fallback timeout + CHECK_SSL_VALIDITY: Fallback SSL check +""" + +import json +import os +import shutil +import subprocess +import sys +from datetime import datetime, timezone +from pathlib import Path + +import rich_click as click + + +# Extractor metadata +EXTRACTOR_NAME = 'media' +BIN_NAME = 'yt-dlp' +BIN_PROVIDERS = 'pip,apt,brew,env' +OUTPUT_DIR = 'media' + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +STATICFILE_DIR = 'staticfile' + +def has_staticfile_output() -> bool: + """Check if staticfile extractor already downloaded this URL.""" + staticfile_dir = Path(STATICFILE_DIR) + return staticfile_dir.exists() and any(staticfile_dir.iterdir()) + + +def find_ytdlp() -> str | None: + """Find yt-dlp binary.""" + ytdlp = get_env('YTDLP_BINARY') or get_env('YOUTUBEDL_BINARY') + if ytdlp and os.path.isfile(ytdlp): + return ytdlp + + for name in ['yt-dlp', 'youtube-dl']: + binary = shutil.which(name) + if binary: + return binary + + return None + + +def get_version(binary: str) -> str: + """Get yt-dlp version.""" + try: + result = subprocess.run([binary, '--version'], capture_output=True, text=True, timeout=10) + return result.stdout.strip()[:64] + except Exception: + return '' + + +# Default yt-dlp args (from old YTDLP_CONFIG) +def get_ytdlp_default_args(media_max_size: str = '750m') -> list[str]: + """Build default yt-dlp arguments.""" + return [ + '--restrict-filenames', + '--trim-filenames', '128', + '--write-description', + '--write-info-json', + '--write-annotations', + '--write-thumbnail', + '--no-call-home', + '--write-sub', + '--write-auto-subs', + '--convert-subs=srt', + '--yes-playlist', + '--continue', + '--no-abort-on-error', + '--ignore-errors', + '--geo-bypass', + '--add-metadata', + f'--format=(bv*+ba/b)[filesize<={media_max_size}][filesize_approx<=?{media_max_size}]/(bv*+ba/b)', + ] + + +def save_media(url: str, binary: str) -> tuple[bool, str | None, str]: + """ + Download media using yt-dlp. + + Returns: (success, output_path, error_message) + """ + # Get config from env (with YTDLP_ prefix or fallback to ARCHIVING_CONFIG style) + timeout = get_env_int('YTDLP_TIMEOUT') or get_env_int('MEDIA_TIMEOUT') or get_env_int('TIMEOUT', 3600) + check_ssl = get_env_bool('YTDLP_CHECK_SSL_VALIDITY', get_env_bool('CHECK_SSL_VALIDITY', True)) + extra_args = get_env('YTDLP_EXTRA_ARGS') or get_env('YOUTUBEDL_EXTRA_ARGS', '') + media_max_size = get_env('MEDIA_MAX_SIZE', '750m') + + # Create output directory + output_dir = Path(OUTPUT_DIR) + output_dir.mkdir(exist_ok=True) + + # Build command (later options take precedence) + cmd = [ + binary, + *get_ytdlp_default_args(media_max_size), + '--no-progress', + '-o', f'{OUTPUT_DIR}/%(title)s.%(ext)s', + ] + + if not check_ssl: + cmd.append('--no-check-certificate') + + if extra_args: + cmd.extend(extra_args.split()) + + cmd.append(url) + + try: + result = subprocess.run(cmd, capture_output=True, timeout=timeout, text=True) + + # Check if any media files were downloaded + media_extensions = ( + '.mp4', '.webm', '.mkv', '.avi', '.mov', '.flv', '.wmv', '.m4v', + '.mp3', '.m4a', '.ogg', '.wav', '.flac', '.aac', '.opus', + '.json', '.jpg', '.png', '.webp', '.jpeg', + '.vtt', '.srt', '.ass', '.lrc', + '.description', + ) + + downloaded_files = [ + f for f in output_dir.glob('*') + if f.is_file() and f.suffix.lower() in media_extensions + ] + + if downloaded_files: + # Return first video/audio file, or first file if no media + video_audio = [ + f for f in downloaded_files + if f.suffix.lower() in ('.mp4', '.webm', '.mkv', '.avi', '.mov', '.mp3', '.m4a', '.ogg', '.wav', '.flac') + ] + output = str(video_audio[0]) if video_audio else str(downloaded_files[0]) + return True, output, '' + else: + stderr = result.stderr + + # These are NOT errors - page simply has no downloadable media + # Return success with no output (legitimate "nothing to download") + if 'ERROR: Unsupported URL' in stderr: + return True, None, '' # Not a media site - success, no output + if 'URL could be a direct video link' in stderr: + return True, None, '' # Not a supported media URL - success, no output + if result.returncode == 0: + return True, None, '' # yt-dlp exited cleanly, just no media - success + + # These ARE errors - something went wrong + if 'HTTP Error 404' in stderr: + return False, None, '404 Not Found' + if 'HTTP Error 403' in stderr: + return False, None, '403 Forbidden' + if 'Unable to extract' in stderr: + return False, None, 'Unable to extract media info' + + return False, None, f'yt-dlp error: {stderr[:200]}' + + except subprocess.TimeoutExpired: + return False, None, f'Timed out after {timeout} seconds' + except Exception as e: + return False, None, f'{type(e).__name__}: {e}' + + +@click.command() +@click.option('--url', required=True, help='URL to download media from') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Download media from a URL using yt-dlp.""" + + start_ts = datetime.now(timezone.utc) + version = '' + output = None + status = 'failed' + error = '' + binary = None + cmd_str = '' + + try: + # Check if yt-dlp is enabled + if not (get_env_bool('USE_YTDLP', True) and get_env_bool('SAVE_MEDIA', True)): + print('Skipping media (USE_YTDLP=False or SAVE_MEDIA=False)') + status = 'skipped' + end_ts = datetime.now(timezone.utc) + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'STATUS={status}') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": status, "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) + + # Check if staticfile extractor already handled this (permanent skip) + if has_staticfile_output(): + print(f'Skipping media - staticfile extractor already downloaded this') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS={status}') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": status, "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) + + # Find binary + binary = find_ytdlp() + if not binary: + print(f'ERROR: {BIN_NAME} binary not found', file=sys.stderr) + print(f'DEPENDENCY_NEEDED={BIN_NAME}', file=sys.stderr) + print(f'BIN_PROVIDERS={BIN_PROVIDERS}', file=sys.stderr) + print(f'INSTALL_HINT=pip install yt-dlp OR brew install yt-dlp', file=sys.stderr) + sys.exit(1) + + version = get_version(binary) + cmd_str = f'{binary} {url}' + + # Run extraction + success, output, error = save_media(url, binary) + status = 'succeeded' if success else 'failed' + + if success: + output_dir = Path(OUTPUT_DIR) + files = list(output_dir.glob('*')) + file_count = len([f for f in files if f.is_file()]) + if file_count > 0: + print(f'yt-dlp completed: {file_count} files downloaded') + else: + print(f'yt-dlp completed: no media found on page (this is normal)') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if cmd_str: + print(f'CMD={cmd_str}') + if version: + print(f'VERSION={version}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'cmd_version': version, + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/mercury/config.json b/archivebox/plugins/mercury/config.json new file mode 100644 index 00000000..2fc97261 --- /dev/null +++ b/archivebox/plugins/mercury/config.json @@ -0,0 +1,30 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "additionalProperties": false, + "properties": { + "SAVE_MERCURY": { + "type": "boolean", + "default": true, + "description": "Enable Mercury text extraction" + }, + "MERCURY_BINARY": { + "type": "string", + "default": "postlight-parser", + "x-aliases": ["POSTLIGHT_PARSER_BINARY"], + "description": "Path to Mercury/Postlight parser binary" + }, + "NODE_BINARY": { + "type": "string", + "default": "node", + "description": "Path to Node.js binary" + }, + "MERCURY_TIMEOUT": { + "type": "integer", + "default": 30, + "minimum": 5, + "x-fallback": "TIMEOUT", + "description": "Timeout for Mercury in seconds" + } + } +} diff --git a/archivebox/plugins/mercury/on_Snapshot__53_mercury.py b/archivebox/plugins/mercury/on_Snapshot__53_mercury.py new file mode 100644 index 00000000..89be4a4d --- /dev/null +++ b/archivebox/plugins/mercury/on_Snapshot__53_mercury.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +""" +Extract article content using Postlight's Mercury Parser. + +Usage: on_Snapshot__mercury.py --url= --snapshot-id= +Output: Creates mercury/ directory with content.html, content.txt, article.json + +Environment variables: + MERCURY_BINARY: Path to mercury-parser binary + TIMEOUT: Timeout in seconds (default: 60) + +Note: Requires mercury-parser: npm install -g @postlight/mercury-parser +""" + +import json +import os +import shutil +import subprocess +import sys +from datetime import datetime, timezone +from pathlib import Path + +import rich_click as click + + +# Extractor metadata +EXTRACTOR_NAME = 'mercury' +BIN_NAME = 'mercury-parser' +BIN_PROVIDERS = 'npm,env' +OUTPUT_DIR = 'mercury' + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +def find_mercury() -> str | None: + """Find mercury-parser binary.""" + mercury = get_env('MERCURY_BINARY') + if mercury and os.path.isfile(mercury): + return mercury + + for name in ['mercury-parser', 'mercury']: + binary = shutil.which(name) + if binary: + return binary + + return None + + +def get_version(binary: str) -> str: + """Get mercury-parser version.""" + try: + result = subprocess.run([binary, '--version'], capture_output=True, text=True, timeout=10) + return result.stdout.strip()[:64] + except Exception: + return '' + + +def extract_mercury(url: str, binary: str) -> tuple[bool, str | None, str]: + """ + Extract article using Mercury Parser. + + Returns: (success, output_path, error_message) + """ + timeout = get_env_int('TIMEOUT', 60) + + # Create output directory + output_dir = Path(OUTPUT_DIR) + output_dir.mkdir(exist_ok=True) + + try: + # Get text version + cmd_text = [binary, url, '--format=text'] + result_text = subprocess.run(cmd_text, capture_output=True, timeout=timeout) + + if result_text.returncode != 0: + stderr = result_text.stderr.decode('utf-8', errors='replace') + return False, None, f'mercury-parser failed: {stderr[:200]}' + + try: + text_json = json.loads(result_text.stdout) + except json.JSONDecodeError: + return False, None, 'mercury-parser returned invalid JSON' + + if text_json.get('failed'): + return False, None, 'Mercury was not able to extract article' + + # Save text content + text_content = text_json.get('content', '') + (output_dir / 'content.txt').write_text(text_content, encoding='utf-8') + + # Get HTML version + cmd_html = [binary, url, '--format=html'] + result_html = subprocess.run(cmd_html, capture_output=True, timeout=timeout) + + try: + html_json = json.loads(result_html.stdout) + except json.JSONDecodeError: + html_json = {} + + # Save HTML content and metadata + html_content = html_json.pop('content', '') + (output_dir / 'content.html').write_text(html_content, encoding='utf-8') + + # Save article metadata + metadata = {k: v for k, v in text_json.items() if k != 'content'} + (output_dir / 'article.json').write_text(json.dumps(metadata, indent=2), encoding='utf-8') + + return True, OUTPUT_DIR, '' + + except subprocess.TimeoutExpired: + return False, None, f'Timed out after {timeout} seconds' + except Exception as e: + return False, None, f'{type(e).__name__}: {e}' + + +@click.command() +@click.option('--url', required=True, help='URL to extract article from') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Extract article content using Postlight's Mercury Parser.""" + + start_ts = datetime.now(timezone.utc) + version = '' + output = None + status = 'failed' + error = '' + binary = None + + try: + # Find binary + binary = find_mercury() + if not binary: + print(f'ERROR: mercury-parser binary not found', file=sys.stderr) + print(f'DEPENDENCY_NEEDED={BIN_NAME}', file=sys.stderr) + print(f'BIN_PROVIDERS={BIN_PROVIDERS}', file=sys.stderr) + sys.exit(1) + + version = get_version(binary) + + # Run extraction + success, output, error = extract_mercury(url, binary) + status = 'succeeded' if success else 'failed' + + if success: + text_file = Path(output) / 'content.txt' + html_file = Path(output) / 'content.html' + text_len = text_file.stat().st_size if text_file.exists() else 0 + html_len = html_file.stat().st_size if html_file.exists() else 0 + print(f'Mercury extracted: {text_len} chars text, {html_len} chars HTML') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if binary: + print(f'CMD={binary} {url}') + if version: + print(f'VERSION={version}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'cmd_version': version, + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/merkletree/on_Snapshot__93_merkletree.py b/archivebox/plugins/merkletree/on_Snapshot__93_merkletree.py new file mode 100755 index 00000000..97757d3f --- /dev/null +++ b/archivebox/plugins/merkletree/on_Snapshot__93_merkletree.py @@ -0,0 +1,295 @@ +#!/usr/bin/env python3 +""" +Create a Merkle tree of all archived outputs. + +This plugin runs after all extractors and post-processing complete (priority 92) +and generates a cryptographic Merkle tree of all files in the snapshot directory. +This provides: + - Tamper detection: verify archive integrity + - Efficient updates: only re-hash changed files + - Compact proofs: prove file inclusion without sending all files + - Deduplication: identify identical content across snapshots + +Output: merkletree/merkletree.json containing: + - root_hash: SHA256 hash of the Merkle root + - tree: Full tree structure with internal nodes + - files: List of all files with their hashes + - metadata: Timestamp, file count, total size + +Usage: on_Snapshot__92_merkletree.py --url= --snapshot-id= + +Environment variables: + SAVE_MERKLETREE: Enable merkle tree generation (default: true) +""" + +__package__ = 'archivebox.plugins.merkletree' + +import os +import sys +import json +import hashlib +from pathlib import Path +from datetime import datetime +from typing import Dict, List, Optional, Tuple, Any + +# Configure Django if running standalone +if __name__ == '__main__': + parent_dir = str(Path(__file__).resolve().parent.parent.parent) + if parent_dir not in sys.path: + sys.path.insert(0, parent_dir) + os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'archivebox.core.settings') + import django + django.setup() + +import rich_click as click + + +def sha256_file(filepath: Path) -> str: + """Compute SHA256 hash of a file.""" + h = hashlib.sha256() + try: + with open(filepath, 'rb') as f: + # Read in 64kb chunks + while chunk := f.read(65536): + h.update(chunk) + return h.hexdigest() + except (OSError, PermissionError): + # If we can't read the file, return a null hash + return '0' * 64 + + +def sha256_data(data: bytes) -> str: + """Compute SHA256 hash of raw data.""" + return hashlib.sha256(data).hexdigest() + + +def collect_files(snapshot_dir: Path, exclude_dirs: Optional[List[str]] = None) -> List[Tuple[Path, str, int]]: + """ + Recursively collect all files in snapshot directory. + + Args: + snapshot_dir: Root directory to scan + exclude_dirs: Directory names to exclude (e.g., ['merkletree', '.git']) + + Returns: + List of (relative_path, sha256_hash, file_size) tuples + """ + exclude_dirs = exclude_dirs or ['merkletree', '.git', '__pycache__'] + files = [] + + for root, dirs, filenames in os.walk(snapshot_dir): + # Filter out excluded directories + dirs[:] = [d for d in dirs if d not in exclude_dirs] + + for filename in filenames: + filepath = Path(root) / filename + rel_path = filepath.relative_to(snapshot_dir) + + # Skip symlinks (we hash the target, not the link) + if filepath.is_symlink(): + continue + + # Compute hash and size + file_hash = sha256_file(filepath) + file_size = filepath.stat().st_size if filepath.exists() else 0 + + files.append((rel_path, file_hash, file_size)) + + # Sort by path for deterministic tree + files.sort(key=lambda x: str(x[0])) + return files + + +def build_merkle_tree(file_hashes: List[str]) -> Tuple[str, List[List[str]]]: + """ + Build a Merkle tree from a list of leaf hashes. + + Args: + file_hashes: List of SHA256 hashes (leaves) + + Returns: + (root_hash, tree_levels) where tree_levels is a list of hash lists per level + """ + if not file_hashes: + # Empty tree + return sha256_data(b''), [[]] + + # Initialize with leaf level + tree_levels = [file_hashes.copy()] + + # Build tree bottom-up + while len(tree_levels[-1]) > 1: + current_level = tree_levels[-1] + next_level = [] + + # Process pairs + for i in range(0, len(current_level), 2): + left = current_level[i] + + if i + 1 < len(current_level): + # Combine left + right + right = current_level[i + 1] + combined = left + right + else: + # Odd number of nodes: duplicate the last one + combined = left + left + + parent_hash = sha256_data(combined.encode('utf-8')) + next_level.append(parent_hash) + + tree_levels.append(next_level) + + # Root is the single hash at the top level + root_hash = tree_levels[-1][0] + return root_hash, tree_levels + + +def create_merkle_tree(snapshot_dir: Path) -> Dict[str, Any]: + """ + Create a complete Merkle tree of all files in snapshot directory. + + Args: + snapshot_dir: The snapshot directory to scan + + Returns: + Dict containing root_hash, tree structure, file list, and metadata + """ + # Collect all files + files = collect_files(snapshot_dir) + + # Extract just the hashes for tree building + file_hashes = [file_hash for _, file_hash, _ in files] + + # Build Merkle tree + root_hash, tree_levels = build_merkle_tree(file_hashes) + + # Calculate total size + total_size = sum(size for _, _, size in files) + + # Prepare file list with metadata + file_list = [ + { + 'path': str(path), + 'hash': file_hash, + 'size': size, + } + for path, file_hash, size in files + ] + + # Prepare result + result = { + 'root_hash': root_hash, + 'tree_levels': tree_levels, + 'files': file_list, + 'metadata': { + 'timestamp': datetime.now().isoformat(), + 'file_count': len(files), + 'total_size': total_size, + 'tree_depth': len(tree_levels), + }, + } + + return result + + +@click.command() +@click.option('--url', required=True, help='URL being archived') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Generate Merkle tree of all archived outputs.""" + from archivebox.core.models import Snapshot + + start_ts = datetime.now() + status = 'failed' + output = None + error = '' + root_hash = None + file_count = 0 + + try: + # Check if enabled + save_merkletree = os.getenv('SAVE_MERKLETREE', 'true').lower() in ('true', '1', 'yes', 'on') + + if not save_merkletree: + click.echo('Skipping merkle tree (SAVE_MERKLETREE=False)') + status = 'skipped' + end_ts = datetime.now() + click.echo(f'START_TS={start_ts.isoformat()}') + click.echo(f'END_TS={end_ts.isoformat()}') + click.echo(f'STATUS={status}') + click.echo(f'RESULT_JSON={{"extractor": "merkletree", "status": "{status}", "url": "{url}", "snapshot_id": "{snapshot_id}"}}') + sys.exit(0) + + # Get snapshot + try: + snapshot = Snapshot.objects.get(id=snapshot_id) + except Snapshot.DoesNotExist: + error = f'Snapshot {snapshot_id} not found' + raise ValueError(error) + + # Get snapshot directory + snapshot_dir = Path(snapshot.output_dir) + if not snapshot_dir.exists(): + error = f'Snapshot directory not found: {snapshot_dir}' + raise FileNotFoundError(error) + + # Create output directory + output_dir = snapshot_dir / 'merkletree' + output_dir.mkdir(exist_ok=True) + output_path = output_dir / 'merkletree.json' + + # Generate Merkle tree + merkle_data = create_merkle_tree(snapshot_dir) + + # Write output + with open(output_path, 'w', encoding='utf-8') as f: + json.dump(merkle_data, f, indent=2) + + status = 'succeeded' + output = str(output_path) + root_hash = merkle_data['root_hash'] + file_count = merkle_data['metadata']['file_count'] + total_size = merkle_data['metadata']['total_size'] + + click.echo(f'Merkle tree created: {file_count} files, root={root_hash[:16]}..., size={total_size:,} bytes') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + click.echo(f'Error: {error}', err=True) + + end_ts = datetime.now() + duration = (end_ts - start_ts).total_seconds() + + # Print results + click.echo(f'START_TS={start_ts.isoformat()}') + click.echo(f'END_TS={end_ts.isoformat()}') + click.echo(f'DURATION={duration:.2f}') + if output: + click.echo(f'OUTPUT={output}') + click.echo(f'STATUS={status}') + + if error: + click.echo(f'ERROR={error}', err=True) + + # Print JSON result + result_json = { + 'extractor': 'merkletree', + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'output': output, + 'root_hash': root_hash, + 'file_count': file_count, + 'error': error or None, + } + click.echo(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/npm/on_Dependency__install_using_npm_provider.py b/archivebox/plugins/npm/on_Dependency__install_using_npm_provider.py new file mode 100644 index 00000000..6a1a30e9 --- /dev/null +++ b/archivebox/plugins/npm/on_Dependency__install_using_npm_provider.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +""" +Install a binary using npm package manager. + +Usage: on_Dependency__install_using_npm_provider.py --dependency-id= --bin-name= [--custom-cmd=] +Output: InstalledBinary JSONL record to stdout after installation + +Environment variables: + MACHINE_ID: Machine UUID (set by orchestrator) +""" + +import json +import os +import sys + +import rich_click as click +from abx_pkg import Binary, NpmProvider, BinProviderOverrides + +# Fix pydantic forward reference issue +NpmProvider.model_rebuild() + + +@click.command() +@click.option('--dependency-id', required=True, help="Dependency UUID") +@click.option('--bin-name', required=True, help="Binary name to install") +@click.option('--bin-providers', default='*', help="Allowed providers (comma-separated)") +@click.option('--custom-cmd', default=None, help="Custom install command") +def main(dependency_id: str, bin_name: str, bin_providers: str, custom_cmd: str | None): + """Install binary using npm.""" + + if bin_providers != '*' and 'npm' not in bin_providers.split(','): + click.echo(f"npm provider not allowed for {bin_name}", err=True) + sys.exit(0) + + # Use abx-pkg NpmProvider to install binary + provider = NpmProvider() + if not provider.INSTALLER_BIN: + click.echo("npm not available on this system", err=True) + sys.exit(1) + + click.echo(f"Installing {bin_name} via npm...", err=True) + + try: + binary = Binary(name=bin_name, binproviders=[provider]).install() + except Exception as e: + click.echo(f"npm install failed: {e}", err=True) + sys.exit(1) + + if not binary.abspath: + click.echo(f"{bin_name} not found after npm install", err=True) + sys.exit(1) + + machine_id = os.environ.get('MACHINE_ID', '') + + # Output InstalledBinary JSONL record to stdout + record = { + 'type': 'InstalledBinary', + 'name': bin_name, + 'abspath': str(binary.abspath), + 'version': str(binary.version) if binary.version else '', + 'sha256': binary.sha256 or '', + 'binprovider': 'npm', + 'machine_id': machine_id, + 'dependency_id': dependency_id, + } + print(json.dumps(record)) + + # Log human-readable info to stderr + click.echo(f"Installed {bin_name} at {binary.abspath}", err=True) + click.echo(f" version: {binary.version}", err=True) + + sys.exit(0) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/parse_dom_outlinks/on_Snapshot__40_parse_dom_outlinks.js b/archivebox/plugins/parse_dom_outlinks/on_Snapshot__40_parse_dom_outlinks.js new file mode 100755 index 00000000..9cff5e33 --- /dev/null +++ b/archivebox/plugins/parse_dom_outlinks/on_Snapshot__40_parse_dom_outlinks.js @@ -0,0 +1,281 @@ +#!/usr/bin/env node +/** + * Extract and categorize outgoing links from a page's DOM. + * + * Categorizes links by type: + * - hrefs: All links + * - images: + * - css_stylesheets: + * - css_images: CSS background-image: url() + * - js_scripts: ', '', html, flags=re.DOTALL | re.IGNORECASE) + html = re.sub(r']*>.*?', '', html, flags=re.DOTALL | re.IGNORECASE) + html = re.sub(r'<[^>]+>', ' ', html) + html = html.replace(' ', ' ').replace('&', '&') + html = html.replace('<', '<').replace('>', '>') + html = html.replace('"', '"') + html = re.sub(r'\s+', ' ', html) + return html.strip() + + +def find_indexable_content() -> list[tuple[str, str]]: + """Find text content to index from extractor outputs.""" + results = [] + cwd = Path.cwd() + + for extractor, file_pattern in INDEXABLE_FILES: + extractor_dir = cwd / extractor + if not extractor_dir.exists(): + continue + + if '*' in file_pattern: + matches = list(extractor_dir.glob(file_pattern)) + else: + match = extractor_dir / file_pattern + matches = [match] if match.exists() else [] + + for match in matches: + if match.is_file() and match.stat().st_size > 0: + try: + content = match.read_text(encoding='utf-8', errors='ignore') + if content.strip(): + if match.suffix in ('.html', '.htm'): + content = strip_html_tags(content) + results.append((f'{extractor}/{match.name}', content)) + except Exception: + continue + + return results + + +def get_sonic_config() -> dict: + """Get Sonic connection configuration.""" + return { + 'host': get_env('SEARCH_BACKEND_HOST_NAME', '127.0.0.1'), + 'port': get_env_int('SEARCH_BACKEND_PORT', 1491), + 'password': get_env('SEARCH_BACKEND_PASSWORD', 'SecretPassword'), + 'collection': get_env('SONIC_COLLECTION', 'archivebox'), + 'bucket': get_env('SONIC_BUCKET', 'snapshots'), + } + + +def index_in_sonic(snapshot_id: str, texts: list[str]) -> None: + """Index texts in Sonic.""" + try: + from sonic import IngestClient + except ImportError: + raise RuntimeError('sonic-client not installed. Run: pip install sonic-client') + + config = get_sonic_config() + + with IngestClient(config['host'], config['port'], config['password']) as ingest: + # Flush existing content + try: + ingest.flush_object(config['collection'], config['bucket'], snapshot_id) + except Exception: + pass + + # Index new content in chunks (Sonic has size limits) + content = ' '.join(texts) + chunk_size = 10000 + for i in range(0, len(content), chunk_size): + chunk = content[i:i + chunk_size] + ingest.push(config['collection'], config['bucket'], snapshot_id, chunk) + + +@click.command() +@click.option('--url', required=True, help='URL that was archived') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Index snapshot content in Sonic.""" + + start_ts = datetime.now(timezone.utc) + output = None + status = 'failed' + error = '' + indexed_sources = [] + + try: + # Check if this backend is enabled (permanent skips - don't retry) + backend = get_env('SEARCH_BACKEND_ENGINE', 'sqlite') + if backend != 'sonic': + print(f'Skipping Sonic indexing (SEARCH_BACKEND_ENGINE={backend})') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - different backend selected + if not get_env_bool('USE_INDEXING_BACKEND', True): + print('Skipping indexing (USE_INDEXING_BACKEND=False)') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - indexing disabled + else: + contents = find_indexable_content() + indexed_sources = [source for source, _ in contents] + + if not contents: + status = 'skipped' + print('No indexable content found') + else: + texts = [content for _, content in contents] + index_in_sonic(snapshot_id, texts) + status = 'succeeded' + output = OUTPUT_DIR + print(f'Sonic indexed {len(texts)} documents') + print(f'Sources: {", ".join(indexed_sources)}') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'output': output, + 'indexed_sources': indexed_sources, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/search_backend_sonic/search.py b/archivebox/plugins/search_backend_sonic/search.py new file mode 100644 index 00000000..f9c518fd --- /dev/null +++ b/archivebox/plugins/search_backend_sonic/search.py @@ -0,0 +1,50 @@ +""" +Sonic search backend - search and flush operations. + +This module provides the search interface for the Sonic backend. +""" + +import os +from typing import List, Iterable + + +def get_sonic_config() -> dict: + """Get Sonic connection configuration.""" + return { + 'host': os.environ.get('SEARCH_BACKEND_HOST_NAME', '127.0.0.1').strip(), + 'port': int(os.environ.get('SEARCH_BACKEND_PORT', '1491')), + 'password': os.environ.get('SEARCH_BACKEND_PASSWORD', 'SecretPassword').strip(), + 'collection': os.environ.get('SONIC_COLLECTION', 'archivebox').strip(), + 'bucket': os.environ.get('SONIC_BUCKET', 'snapshots').strip(), + } + + +def search(query: str) -> List[str]: + """Search for snapshots in Sonic.""" + try: + from sonic import SearchClient + except ImportError: + raise RuntimeError('sonic-client not installed. Run: pip install sonic-client') + + config = get_sonic_config() + + with SearchClient(config['host'], config['port'], config['password']) as search_client: + results = search_client.query(config['collection'], config['bucket'], query, limit=100) + return results + + +def flush(snapshot_ids: Iterable[str]) -> None: + """Remove snapshots from Sonic index.""" + try: + from sonic import IngestClient + except ImportError: + raise RuntimeError('sonic-client not installed. Run: pip install sonic-client') + + config = get_sonic_config() + + with IngestClient(config['host'], config['port'], config['password']) as ingest: + for snapshot_id in snapshot_ids: + try: + ingest.flush_object(config['collection'], config['bucket'], snapshot_id) + except Exception: + pass diff --git a/archivebox/pkgs/abx-plugin-curl/README.md b/archivebox/plugins/search_backend_sqlite/__init__.py similarity index 100% rename from archivebox/pkgs/abx-plugin-curl/README.md rename to archivebox/plugins/search_backend_sqlite/__init__.py diff --git a/archivebox/plugins/search_backend_sqlite/config.json b/archivebox/plugins/search_backend_sqlite/config.json new file mode 100644 index 00000000..d0cbf294 --- /dev/null +++ b/archivebox/plugins/search_backend_sqlite/config.json @@ -0,0 +1,24 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "additionalProperties": false, + "properties": { + "SQLITEFTS_DB": { + "type": "string", + "default": "search.sqlite3", + "description": "SQLite FTS database filename" + }, + "FTS_SEPARATE_DATABASE": { + "type": "boolean", + "default": true, + "x-aliases": ["SQLITEFTS_SEPARATE_DATABASE"], + "description": "Use separate database file for FTS index" + }, + "FTS_TOKENIZERS": { + "type": "string", + "default": "porter unicode61 remove_diacritics 2", + "x-aliases": ["SQLITEFTS_TOKENIZERS"], + "description": "FTS5 tokenizer configuration" + } + } +} diff --git a/archivebox/plugins/search_backend_sqlite/on_Snapshot__90_index_sqlite.py b/archivebox/plugins/search_backend_sqlite/on_Snapshot__90_index_sqlite.py new file mode 100644 index 00000000..36445ded --- /dev/null +++ b/archivebox/plugins/search_backend_sqlite/on_Snapshot__90_index_sqlite.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python3 +""" +SQLite FTS5 search backend - indexes snapshot content for full-text search. + +This hook runs after all extractors and indexes text content in SQLite FTS5. +Only runs if SEARCH_BACKEND_ENGINE=sqlite. + +Usage: on_Snapshot__90_index_sqlite.py --url= --snapshot-id= + +Environment variables: + SEARCH_BACKEND_ENGINE: Must be 'sqlite' for this hook to run + USE_INDEXING_BACKEND: Enable search indexing (default: true) + SQLITEFTS_DB: Database filename (default: search.sqlite3) + FTS_TOKENIZERS: FTS5 tokenizer config (default: porter unicode61 remove_diacritics 2) +""" + +import json +import os +import re +import sqlite3 +import sys +from datetime import datetime, timezone +from pathlib import Path + +import rich_click as click + + +# Extractor metadata +EXTRACTOR_NAME = 'index_sqlite' +OUTPUT_DIR = 'search_index' + +# Text file patterns to index, in priority order +INDEXABLE_FILES = [ + ('readability', 'content.txt'), + ('readability', 'content.html'), + ('mercury', 'content.txt'), + ('mercury', 'content.html'), + ('htmltotext', 'output.txt'), + ('singlefile', 'singlefile.html'), + ('dom', 'output.html'), + ('wget', '**/*.html'), + ('wget', '**/*.htm'), + ('title', 'title.txt'), +] + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + + +def strip_html_tags(html: str) -> str: + """Remove HTML tags, keeping text content.""" + html = re.sub(r']*>.*?', '', html, flags=re.DOTALL | re.IGNORECASE) + html = re.sub(r']*>.*?', '', html, flags=re.DOTALL | re.IGNORECASE) + html = re.sub(r'<[^>]+>', ' ', html) + html = html.replace(' ', ' ').replace('&', '&') + html = html.replace('<', '<').replace('>', '>') + html = html.replace('"', '"') + html = re.sub(r'\s+', ' ', html) + return html.strip() + + +def find_indexable_content() -> list[tuple[str, str]]: + """Find text content to index from extractor outputs.""" + results = [] + cwd = Path.cwd() + + for extractor, file_pattern in INDEXABLE_FILES: + extractor_dir = cwd / extractor + if not extractor_dir.exists(): + continue + + if '*' in file_pattern: + matches = list(extractor_dir.glob(file_pattern)) + else: + match = extractor_dir / file_pattern + matches = [match] if match.exists() else [] + + for match in matches: + if match.is_file() and match.stat().st_size > 0: + try: + content = match.read_text(encoding='utf-8', errors='ignore') + if content.strip(): + if match.suffix in ('.html', '.htm'): + content = strip_html_tags(content) + results.append((f'{extractor}/{match.name}', content)) + except Exception: + continue + + return results + + +def get_db_path() -> Path: + """Get path to the search index database.""" + data_dir = get_env('DATA_DIR', str(Path.cwd().parent.parent)) + db_name = get_env('SQLITEFTS_DB', 'search.sqlite3') + return Path(data_dir) / db_name + + +def index_in_sqlite(snapshot_id: str, texts: list[str]) -> None: + """Index texts in SQLite FTS5.""" + db_path = get_db_path() + tokenizers = get_env('FTS_TOKENIZERS', 'porter unicode61 remove_diacritics 2') + conn = sqlite3.connect(str(db_path)) + + try: + # Create FTS5 table if needed + conn.execute(f''' + CREATE VIRTUAL TABLE IF NOT EXISTS search_index + USING fts5(snapshot_id, content, tokenize='{tokenizers}') + ''') + + # Remove existing entries + conn.execute('DELETE FROM search_index WHERE snapshot_id = ?', (snapshot_id,)) + + # Insert new content + content = '\n\n'.join(texts) + conn.execute( + 'INSERT INTO search_index (snapshot_id, content) VALUES (?, ?)', + (snapshot_id, content) + ) + conn.commit() + finally: + conn.close() + + +@click.command() +@click.option('--url', required=True, help='URL that was archived') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Index snapshot content in SQLite FTS5.""" + + start_ts = datetime.now(timezone.utc) + output = None + status = 'failed' + error = '' + indexed_sources = [] + + try: + # Check if this backend is enabled (permanent skips - don't retry) + backend = get_env('SEARCH_BACKEND_ENGINE', 'sqlite') + if backend != 'sqlite': + print(f'Skipping SQLite indexing (SEARCH_BACKEND_ENGINE={backend})') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - different backend selected + if not get_env_bool('USE_INDEXING_BACKEND', True): + print('Skipping indexing (USE_INDEXING_BACKEND=False)') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - indexing disabled + else: + contents = find_indexable_content() + indexed_sources = [source for source, _ in contents] + + if not contents: + status = 'skipped' + print('No indexable content found') + else: + texts = [content for _, content in contents] + index_in_sqlite(snapshot_id, texts) + status = 'succeeded' + output = OUTPUT_DIR + print(f'SQLite FTS indexed {len(texts)} documents') + print(f'Sources: {", ".join(indexed_sources)}') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'output': output, + 'indexed_sources': indexed_sources, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/search_backend_sqlite/search.py b/archivebox/plugins/search_backend_sqlite/search.py new file mode 100644 index 00000000..afd52f15 --- /dev/null +++ b/archivebox/plugins/search_backend_sqlite/search.py @@ -0,0 +1,65 @@ +""" +SQLite FTS5 search backend - search and flush operations. + +This module provides the search interface for the SQLite FTS backend. + +Environment variables: + SQLITEFTS_DB: Database filename (default: search.sqlite3) + FTS_SEPARATE_DATABASE: Use separate database file (default: true) + FTS_TOKENIZERS: FTS5 tokenizer config (default: porter unicode61 remove_diacritics 2) +""" + +import os +import sqlite3 +from pathlib import Path +from typing import List, Iterable + +from django.conf import settings + + +# Config with old var names for backwards compatibility +SQLITEFTS_DB = os.environ.get('SQLITEFTS_DB', 'search.sqlite3').strip() +FTS_SEPARATE_DATABASE = os.environ.get('FTS_SEPARATE_DATABASE', 'true').lower() in ('true', '1', 'yes') +FTS_TOKENIZERS = os.environ.get('FTS_TOKENIZERS', 'porter unicode61 remove_diacritics 2').strip() + + +def get_db_path() -> Path: + """Get path to the search index database.""" + return Path(settings.DATA_DIR) / SQLITEFTS_DB + + +def search(query: str) -> List[str]: + """Search for snapshots matching the query.""" + db_path = get_db_path() + if not db_path.exists(): + return [] + + conn = sqlite3.connect(str(db_path)) + try: + cursor = conn.execute( + 'SELECT DISTINCT snapshot_id FROM search_index WHERE search_index MATCH ?', + (query,) + ) + return [row[0] for row in cursor.fetchall()] + except sqlite3.OperationalError: + # Table doesn't exist yet + return [] + finally: + conn.close() + + +def flush(snapshot_ids: Iterable[str]) -> None: + """Remove snapshots from the index.""" + db_path = get_db_path() + if not db_path.exists(): + return + + conn = sqlite3.connect(str(db_path)) + try: + for snapshot_id in snapshot_ids: + conn.execute('DELETE FROM search_index WHERE snapshot_id = ?', (snapshot_id,)) + conn.commit() + except sqlite3.OperationalError: + pass # Table doesn't exist + finally: + conn.close() diff --git a/archivebox/plugins/seo/on_Snapshot__38_seo.js b/archivebox/plugins/seo/on_Snapshot__38_seo.js new file mode 100755 index 00000000..3effeff3 --- /dev/null +++ b/archivebox/plugins/seo/on_Snapshot__38_seo.js @@ -0,0 +1,219 @@ +#!/usr/bin/env node +/** + * Extract SEO metadata from a URL. + * + * Extracts all tags including: + * - og:* (Open Graph) + * - twitter:* + * - description, keywords, author + * - Any other meta tags + * + * Usage: on_Snapshot__17_seo.js --url= --snapshot-id= + * Output: Writes seo/seo.json + * + * Environment variables: + * SAVE_SEO: Enable SEO extraction (default: true) + */ + +const fs = require('fs'); +const path = require('path'); +const puppeteer = require('puppeteer-core'); + +// Extractor metadata +const EXTRACTOR_NAME = 'seo'; +const OUTPUT_DIR = 'seo'; +const OUTPUT_FILE = 'seo.json'; +const CHROME_SESSION_DIR = 'chrome_session'; + +// Parse command line arguments +function parseArgs() { + const args = {}; + process.argv.slice(2).forEach(arg => { + if (arg.startsWith('--')) { + const [key, ...valueParts] = arg.slice(2).split('='); + args[key.replace(/-/g, '_')] = valueParts.join('=') || true; + } + }); + return args; +} + +// Get environment variable with default +function getEnv(name, defaultValue = '') { + return (process.env[name] || defaultValue).trim(); +} + +function getEnvBool(name, defaultValue = false) { + const val = getEnv(name, '').toLowerCase(); + if (['true', '1', 'yes', 'on'].includes(val)) return true; + if (['false', '0', 'no', 'off'].includes(val)) return false; + return defaultValue; +} + +// Get CDP URL from chrome_session +function getCdpUrl() { + const cdpFile = path.join(CHROME_SESSION_DIR, 'cdp_url.txt'); + if (fs.existsSync(cdpFile)) { + return fs.readFileSync(cdpFile, 'utf8').trim(); + } + return null; +} + +// Extract SEO metadata +async function extractSeo(url) { + // Create output directory + if (!fs.existsSync(OUTPUT_DIR)) { + fs.mkdirSync(OUTPUT_DIR, { recursive: true }); + } + const outputPath = path.join(OUTPUT_DIR, OUTPUT_FILE); + + let browser = null; + + try { + // Connect to existing Chrome session + const cdpUrl = getCdpUrl(); + if (!cdpUrl) { + return { success: false, error: 'No Chrome session found (chrome_session extractor must run first)' }; + } + + browser = await puppeteer.connect({ + browserWSEndpoint: cdpUrl, + }); + + // Get the page + const pages = await browser.pages(); + const page = pages.find(p => p.url().startsWith('http')) || pages[0]; + + if (!page) { + return { success: false, error: 'No page found in Chrome session' }; + } + + // Extract all meta tags + const seoData = await page.evaluate(() => { + const metaTags = Array.from(document.querySelectorAll('meta')); + const seo = { + url: window.location.href, + title: document.title || '', + }; + + // Process each meta tag + metaTags.forEach(tag => { + // Get the key (name or property attribute) + const key = tag.getAttribute('name') || tag.getAttribute('property') || ''; + const content = tag.getAttribute('content') || ''; + + if (key && content) { + // Store by key + seo[key] = content; + } + }); + + // Also get canonical URL if present + const canonical = document.querySelector('link[rel="canonical"]'); + if (canonical) { + seo.canonical = canonical.getAttribute('href'); + } + + // Get language + const htmlLang = document.documentElement.lang; + if (htmlLang) { + seo.language = htmlLang; + } + + return seo; + }); + + // Write output + fs.writeFileSync(outputPath, JSON.stringify(seoData, null, 2)); + + return { success: true, output: outputPath, seoData }; + + } catch (e) { + return { success: false, error: `${e.name}: ${e.message}` }; + } finally { + if (browser) { + browser.disconnect(); + } + } +} + +async function main() { + const args = parseArgs(); + const url = args.url; + const snapshotId = args.snapshot_id; + + if (!url || !snapshotId) { + console.error('Usage: on_Snapshot__17_seo.js --url= --snapshot-id='); + process.exit(1); + } + + const startTs = new Date(); + let status = 'failed'; + let output = null; + let error = ''; + + try { + // Check if enabled + if (!getEnvBool('SAVE_SEO', true)) { + console.log('Skipping SEO (SAVE_SEO=False)'); + status = 'skipped'; + const endTs = new Date(); + console.log(`START_TS=${startTs.toISOString()}`); + console.log(`END_TS=${endTs.toISOString()}`); + console.log(`STATUS=${status}`); + console.log(`RESULT_JSON=${JSON.stringify({extractor: EXTRACTOR_NAME, status, url, snapshot_id: snapshotId})}`); + process.exit(0); + } + + const result = await extractSeo(url); + + if (result.success) { + status = 'succeeded'; + output = result.output; + const metaCount = Object.keys(result.seoData).length - 2; // Subtract url and title + console.log(`SEO metadata extracted: ${metaCount} meta tags`); + } else { + status = 'failed'; + error = result.error; + } + } catch (e) { + error = `${e.name}: ${e.message}`; + status = 'failed'; + } + + const endTs = new Date(); + const duration = (endTs - startTs) / 1000; + + // Print results + console.log(`START_TS=${startTs.toISOString()}`); + console.log(`END_TS=${endTs.toISOString()}`); + console.log(`DURATION=${duration.toFixed(2)}`); + if (output) { + console.log(`OUTPUT=${output}`); + } + console.log(`STATUS=${status}`); + + if (error) { + console.error(`ERROR=${error}`); + } + + // Print JSON result + const resultJson = { + extractor: EXTRACTOR_NAME, + url, + snapshot_id: snapshotId, + status, + start_ts: startTs.toISOString(), + end_ts: endTs.toISOString(), + duration: Math.round(duration * 100) / 100, + output, + error: error || null, + }; + console.log(`RESULT_JSON=${JSON.stringify(resultJson)}`); + + process.exit(status === 'succeeded' ? 0 : 1); +} + +main().catch(e => { + console.error(`Fatal error: ${e.message}`); + process.exit(1); +}); diff --git a/archivebox/plugins/singlefile/config.json b/archivebox/plugins/singlefile/config.json new file mode 100644 index 00000000..4ebe2208 --- /dev/null +++ b/archivebox/plugins/singlefile/config.json @@ -0,0 +1,53 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "additionalProperties": false, + "properties": { + "SAVE_SINGLEFILE": { + "type": "boolean", + "default": true, + "description": "Enable SingleFile archiving" + }, + "SINGLEFILE_BINARY": { + "type": "string", + "default": "single-file", + "x-aliases": ["SINGLE_FILE_BINARY"], + "description": "Path to single-file binary" + }, + "NODE_BINARY": { + "type": "string", + "default": "node", + "description": "Path to Node.js binary" + }, + "SINGLEFILE_TIMEOUT": { + "type": "integer", + "default": 60, + "minimum": 10, + "x-fallback": "TIMEOUT", + "description": "Timeout for SingleFile in seconds" + }, + "SINGLEFILE_USER_AGENT": { + "type": "string", + "default": "", + "x-fallback": "USER_AGENT", + "description": "User agent string" + }, + "SINGLEFILE_COOKIES_FILE": { + "type": "string", + "default": "", + "x-fallback": "COOKIES_FILE", + "description": "Path to cookies file" + }, + "SINGLEFILE_ARGS": { + "type": "array", + "items": {"type": "string"}, + "default": [], + "description": "Default single-file arguments" + }, + "SINGLEFILE_EXTRA_ARGS": { + "type": "string", + "default": "", + "description": "Extra arguments for single-file" + } + } +} diff --git a/archivebox/plugins/singlefile/on_Crawl__00_validate_singlefile.py b/archivebox/plugins/singlefile/on_Crawl__00_validate_singlefile.py new file mode 100644 index 00000000..db3f3bec --- /dev/null +++ b/archivebox/plugins/singlefile/on_Crawl__00_validate_singlefile.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 +""" +Validation hook for single-file binary. + +Runs at crawl start to verify single-file (npm package) is available. +Outputs JSONL for InstalledBinary and Machine config updates. +""" + +import os +import sys +import json +import shutil +import hashlib +import subprocess +from pathlib import Path + + +def get_binary_version(abspath: str) -> str | None: + """Get version string from single-file binary.""" + try: + result = subprocess.run( + [abspath, '--version'], + capture_output=True, + text=True, + timeout=10, + ) + if result.returncode == 0 and result.stdout: + return result.stdout.strip().split('\n')[0][:32] + except Exception: + pass + return None + + +def get_binary_hash(abspath: str) -> str | None: + """Get SHA256 hash of binary.""" + try: + # For scripts, hash the script content + with open(abspath, 'rb') as f: + return hashlib.sha256(f.read()).hexdigest() + except Exception: + return None + + +def find_singlefile() -> dict | None: + """Find single-file binary.""" + # Check env var first + env_path = os.environ.get('SINGLEFILE_BINARY', '') + if env_path and Path(env_path).is_file(): + return { + 'name': 'single-file', + 'abspath': env_path, + 'version': get_binary_version(env_path), + 'sha256': get_binary_hash(env_path), + 'binprovider': 'env', + } + + # Try shutil.which + for name in ['single-file', 'singlefile']: + abspath = shutil.which(name) + if abspath: + return { + 'name': 'single-file', + 'abspath': abspath, + 'version': get_binary_version(abspath), + 'sha256': get_binary_hash(abspath), + 'binprovider': 'npm', + } + + # Check common npm paths + npm_paths = [ + Path.home() / '.npm-global/bin/single-file', + Path.home() / 'node_modules/.bin/single-file', + Path('/usr/local/bin/single-file'), + Path('/usr/local/lib/node_modules/.bin/single-file'), + ] + for path in npm_paths: + if path.is_file(): + return { + 'name': 'single-file', + 'abspath': str(path), + 'version': get_binary_version(str(path)), + 'sha256': get_binary_hash(str(path)), + 'binprovider': 'npm', + } + + return None + + +def main(): + result = find_singlefile() + + if result and result.get('abspath'): + print(json.dumps({ + 'type': 'InstalledBinary', + 'name': result['name'], + 'abspath': result['abspath'], + 'version': result['version'], + 'sha256': result['sha256'], + 'binprovider': result['binprovider'], + })) + + print(json.dumps({ + 'type': 'Machine', + '_method': 'update', + 'key': 'config/SINGLEFILE_BINARY', + 'value': result['abspath'], + })) + + if result['version']: + print(json.dumps({ + 'type': 'Machine', + '_method': 'update', + 'key': 'config/SINGLEFILE_VERSION', + 'value': result['version'], + })) + + sys.exit(0) + else: + print(json.dumps({ + 'type': 'Dependency', + 'bin_name': 'single-file', + 'bin_providers': 'npm,env', + })) + print(f"single-file binary not found", file=sys.stderr) + sys.exit(1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/singlefile/on_Snapshot__04_singlefile.js b/archivebox/plugins/singlefile/on_Snapshot__04_singlefile.js new file mode 100755 index 00000000..6d9a6710 --- /dev/null +++ b/archivebox/plugins/singlefile/on_Snapshot__04_singlefile.js @@ -0,0 +1,270 @@ +#!/usr/bin/env node +/** + * SingleFile Extension Plugin + * + * Installs and uses the SingleFile Chrome extension for archiving complete web pages. + * Falls back to single-file-cli if the extension is not available. + * + * Extension: https://chromewebstore.google.com/detail/mpiodijhokgodhhofbcjdecpffjipkle + * + * Priority: 04 (early) - Must install before Chrome session starts + * Hook: on_Snapshot + * + * This extension automatically: + * - Saves complete web pages as single HTML files + * - Inlines all resources (CSS, JS, images, fonts) + * - Preserves page fidelity better than wget/curl + * - Works with SPAs and dynamically loaded content + */ + +const path = require('path'); +const fs = require('fs'); +const { promisify } = require('util'); +const { exec } = require('child_process'); + +const execAsync = promisify(exec); + +// Import extension utilities +const extensionUtils = require('../chrome_extensions/chrome_extension_utils.js'); + +// Extension metadata +const EXTENSION = { + webstore_id: 'mpiodijhokgodhhofbcjdecpffjipkle', + name: 'singlefile', +}; + +// Get extensions directory from environment or use default +const EXTENSIONS_DIR = process.env.CHROME_EXTENSIONS_DIR || + path.join(process.env.DATA_DIR || './data', 'personas', process.env.ACTIVE_PERSONA || 'Default', 'chrome_extensions'); + +const CHROME_DOWNLOADS_DIR = process.env.CHROME_DOWNLOADS_DIR || + path.join(process.env.DATA_DIR || './data', 'personas', process.env.ACTIVE_PERSONA || 'Default', 'chrome_downloads'); + +const OUTPUT_DIR = 'singlefile'; +const OUTPUT_FILE = 'singlefile.html'; + +/** + * Install the SingleFile extension + */ +async function installSinglefileExtension() { + console.log('[*] Installing SingleFile extension...'); + + // Install the extension + const extension = await extensionUtils.loadOrInstallExtension(EXTENSION, EXTENSIONS_DIR); + + if (!extension) { + console.error('[❌] Failed to install SingleFile extension'); + return null; + } + + console.log('[+] SingleFile extension installed'); + console.log('[+] Web pages will be saved as single HTML files'); + + return extension; +} + +/** + * Wait for a specified amount of time + */ +function wait(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +/** + * Save a page using the SingleFile extension + * + * @param {Object} page - Puppeteer page object + * @param {Object} extension - Extension metadata with dispatchAction method + * @param {Object} options - Additional options + * @returns {Promise} - Path to saved file or null on failure + */ +async function saveSinglefileWithExtension(page, extension, options = {}) { + if (!extension || !extension.version) { + throw new Error('SingleFile extension not found or not loaded'); + } + + const url = await page.url(); + + // Check for unsupported URL schemes + const URL_SCHEMES_IGNORED = ['about', 'chrome', 'chrome-extension', 'data', 'javascript', 'blob']; + const scheme = url.split(':')[0]; + if (URL_SCHEMES_IGNORED.includes(scheme)) { + console.log(`[⚠️] Skipping SingleFile for URL scheme: ${scheme}`); + return null; + } + + // Ensure downloads directory exists + await fs.promises.mkdir(CHROME_DOWNLOADS_DIR, { recursive: true }); + + // Get list of existing files to ignore + const files_before = new Set( + (await fs.promises.readdir(CHROME_DOWNLOADS_DIR)) + .filter(fn => fn.endsWith('.html')) + ); + + // Ensure output directory exists + await fs.promises.mkdir(OUTPUT_DIR, { recursive: true }); + const out_path = path.join(OUTPUT_DIR, OUTPUT_FILE); + + console.log(`[🛠️] Saving SingleFile HTML using extension (${extension.id})...`); + + // Bring page to front (extension action button acts on foreground tab) + await page.bringToFront(); + + // Trigger the extension's action (toolbar button click) + await extension.dispatchAction(); + + // Wait for file to appear in downloads directory + const check_delay = 3000; // 3 seconds + const max_tries = 10; + let files_new = []; + + for (let attempt = 0; attempt < max_tries; attempt++) { + await wait(check_delay); + + const files_after = (await fs.promises.readdir(CHROME_DOWNLOADS_DIR)) + .filter(fn => fn.endsWith('.html')); + + files_new = files_after.filter(file => !files_before.has(file)); + + if (files_new.length === 0) { + continue; + } + + // Find the matching file by checking if it contains the URL in the HTML header + for (const file of files_new) { + const dl_path = path.join(CHROME_DOWNLOADS_DIR, file); + const dl_text = await fs.promises.readFile(dl_path, 'utf-8'); + const dl_header = dl_text.split('meta charset')[0]; + + if (dl_header.includes(`url: ${url}`)) { + console.log(`[✍️] Moving SingleFile download from ${file} to ${out_path}`); + await fs.promises.rename(dl_path, out_path); + return out_path; + } + } + } + + console.warn(`[❌] Couldn't find matching SingleFile HTML in ${CHROME_DOWNLOADS_DIR} after waiting ${(check_delay * max_tries) / 1000}s`); + console.warn(`[⚠️] New files found: ${files_new.join(', ')}`); + return null; +} + +/** + * Save a page using single-file-cli (fallback method) + * + * @param {string} url - URL to archive + * @param {Object} options - Additional options + * @returns {Promise} - Path to saved file or null on failure + */ +async function saveSinglefileWithCLI(url, options = {}) { + console.log('[*] Falling back to single-file-cli...'); + + // Find single-file binary + let binary = null; + try { + const { stdout } = await execAsync('which single-file'); + binary = stdout.trim(); + } catch (err) { + console.error('[❌] single-file-cli not found. Install with: npm install -g single-file-cli'); + return null; + } + + // Ensure output directory exists + await fs.promises.mkdir(OUTPUT_DIR, { recursive: true }); + const out_path = path.join(OUTPUT_DIR, OUTPUT_FILE); + + // Build command + const cmd = [ + binary, + '--browser-headless', + url, + out_path, + ]; + + // Add optional args + if (options.userAgent) { + cmd.splice(2, 0, '--browser-user-agent', options.userAgent); + } + if (options.cookiesFile && fs.existsSync(options.cookiesFile)) { + cmd.splice(2, 0, '--browser-cookies-file', options.cookiesFile); + } + if (options.ignoreSSL) { + cmd.splice(2, 0, '--browser-ignore-insecure-certs'); + } + + // Execute + try { + const timeout = options.timeout || 120000; + await execAsync(cmd.join(' '), { timeout }); + + if (fs.existsSync(out_path) && fs.statSync(out_path).size > 0) { + console.log(`[+] SingleFile saved via CLI: ${out_path}`); + return out_path; + } + + console.error('[❌] SingleFile CLI completed but no output file found'); + return null; + } catch (err) { + console.error(`[❌] SingleFile CLI error: ${err.message}`); + return null; + } +} + +/** + * Main entry point - install extension before archiving + */ +async function main() { + // Check if extension is already cached + const cacheFile = path.join(EXTENSIONS_DIR, 'singlefile.extension.json'); + + if (fs.existsSync(cacheFile)) { + try { + const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); + const manifestPath = path.join(cached.unpacked_path, 'manifest.json'); + + if (fs.existsSync(manifestPath)) { + console.log('[*] SingleFile extension already installed (using cache)'); + return cached; + } + } catch (e) { + // Cache file corrupted, re-install + console.warn('[⚠️] Extension cache corrupted, re-installing...'); + } + } + + // Install extension + const extension = await installSinglefileExtension(); + + // Export extension metadata for chrome_session to load + if (extension) { + // Write extension info to a cache file that chrome_session can read + await fs.promises.mkdir(EXTENSIONS_DIR, { recursive: true }); + await fs.promises.writeFile( + cacheFile, + JSON.stringify(extension, null, 2) + ); + console.log(`[+] Extension metadata written to ${cacheFile}`); + } + + return extension; +} + +// Export functions for use by other plugins +module.exports = { + EXTENSION, + installSinglefileExtension, + saveSinglefileWithExtension, + saveSinglefileWithCLI, +}; + +// Run if executed directly +if (require.main === module) { + main().then(() => { + console.log('[✓] SingleFile extension setup complete'); + process.exit(0); + }).catch(err => { + console.error('[❌] SingleFile extension setup failed:', err); + process.exit(1); + }); +} diff --git a/archivebox/plugins/singlefile/on_Snapshot__37_singlefile.py b/archivebox/plugins/singlefile/on_Snapshot__37_singlefile.py new file mode 100644 index 00000000..1dfcfe23 --- /dev/null +++ b/archivebox/plugins/singlefile/on_Snapshot__37_singlefile.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python3 +""" +Archive a URL using SingleFile. + +Usage: on_Snapshot__singlefile.py --url= --snapshot-id= +Output: Writes singlefile.html to $PWD + +Environment variables: + SINGLEFILE_BINARY: Path to SingleFile binary + SINGLEFILE_TIMEOUT: Timeout in seconds (default: 120) + SINGLEFILE_USER_AGENT: User agent string (optional) + SINGLEFILE_CHECK_SSL_VALIDITY: Whether to check SSL certificates (default: True) + SINGLEFILE_COOKIES_FILE: Path to cookies file (optional) + SINGLEFILE_EXTRA_ARGS: Extra arguments for SingleFile (space-separated) + + # Feature toggle + SAVE_SINGLEFILE: Enable SingleFile archiving (default: True) + + # Chrome binary (SingleFile needs Chrome) + CHROME_BINARY: Path to Chrome/Chromium binary + + # Fallback to ARCHIVING_CONFIG values if SINGLEFILE_* not set: + TIMEOUT: Fallback timeout + USER_AGENT: Fallback user agent + CHECK_SSL_VALIDITY: Fallback SSL check + COOKIES_FILE: Fallback cookies file +""" + +import json +import os +import shutil +import subprocess +import sys +from datetime import datetime, timezone +from pathlib import Path + +import rich_click as click + + +# Extractor metadata +EXTRACTOR_NAME = 'singlefile' +BIN_NAME = 'single-file' +BIN_PROVIDERS = 'npm,env' +OUTPUT_DIR = 'singlefile' +OUTPUT_FILE = 'singlefile.html' + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +STATICFILE_DIR = 'staticfile' + +def has_staticfile_output() -> bool: + """Check if staticfile extractor already downloaded this URL.""" + staticfile_dir = Path(STATICFILE_DIR) + return staticfile_dir.exists() and any(staticfile_dir.iterdir()) + + +# Chrome binary search paths +CHROMIUM_BINARY_NAMES_LINUX = [ + 'chromium', 'chromium-browser', 'chromium-browser-beta', + 'chromium-browser-unstable', 'chromium-browser-canary', 'chromium-browser-dev', +] +CHROME_BINARY_NAMES_LINUX = [ + 'google-chrome', 'google-chrome-stable', 'google-chrome-beta', + 'google-chrome-canary', 'google-chrome-unstable', 'google-chrome-dev', 'chrome', +] +CHROME_BINARY_NAMES_MACOS = [ + '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', + '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary', +] +CHROMIUM_BINARY_NAMES_MACOS = ['/Applications/Chromium.app/Contents/MacOS/Chromium'] + +ALL_CHROME_BINARIES = ( + CHROME_BINARY_NAMES_LINUX + CHROMIUM_BINARY_NAMES_LINUX + + CHROME_BINARY_NAMES_MACOS + CHROMIUM_BINARY_NAMES_MACOS +) + + +def find_singlefile() -> str | None: + """Find SingleFile binary.""" + singlefile = get_env('SINGLEFILE_BINARY') + if singlefile and os.path.isfile(singlefile): + return singlefile + + for name in ['single-file', 'singlefile']: + binary = shutil.which(name) + if binary: + return binary + + return None + + +def find_chrome() -> str | None: + """Find Chrome/Chromium binary.""" + chrome = get_env('CHROME_BINARY') + if chrome and os.path.isfile(chrome): + return chrome + + for name in ALL_CHROME_BINARIES: + if '/' in name: + if os.path.isfile(name): + return name + else: + binary = shutil.which(name) + if binary: + return binary + + return None + + +def get_version(binary: str) -> str: + """Get SingleFile version.""" + try: + result = subprocess.run([binary, '--version'], capture_output=True, text=True, timeout=10) + return result.stdout.strip()[:64] + except Exception: + return '' + + +CHROME_SESSION_DIR = 'chrome_session' + + +def get_cdp_url() -> str | None: + """Get CDP URL from chrome_session if available.""" + cdp_file = Path(CHROME_SESSION_DIR) / 'cdp_url.txt' + if cdp_file.exists(): + return cdp_file.read_text().strip() + return None + + +def get_port_from_cdp_url(cdp_url: str) -> str | None: + """Extract port from CDP WebSocket URL (ws://127.0.0.1:PORT/...).""" + import re + match = re.search(r':(\d+)/', cdp_url) + if match: + return match.group(1) + return None + + +def save_singlefile(url: str, binary: str) -> tuple[bool, str | None, str]: + """ + Archive URL using SingleFile. + + If a Chrome session exists (from chrome_session extractor), connects to it via CDP. + Otherwise launches a new Chrome instance. + + Returns: (success, output_path, error_message) + """ + # Get config from env (with SINGLEFILE_ prefix or fallback to ARCHIVING_CONFIG style) + timeout = get_env_int('SINGLEFILE_TIMEOUT') or get_env_int('TIMEOUT', 120) + user_agent = get_env('SINGLEFILE_USER_AGENT') or get_env('USER_AGENT', '') + check_ssl = get_env_bool('SINGLEFILE_CHECK_SSL_VALIDITY', get_env_bool('CHECK_SSL_VALIDITY', True)) + cookies_file = get_env('SINGLEFILE_COOKIES_FILE') or get_env('COOKIES_FILE', '') + extra_args = get_env('SINGLEFILE_EXTRA_ARGS', '') + chrome = find_chrome() + + cmd = [binary] + + # Try to use existing Chrome session via CDP + cdp_url = get_cdp_url() + if cdp_url: + # SingleFile can connect to existing browser via WebSocket + # Extract port from CDP URL (ws://127.0.0.1:PORT/...) + port = get_port_from_cdp_url(cdp_url) + if port: + cmd.extend(['--browser-server', f'http://127.0.0.1:{port}']) + elif chrome: + cmd.extend(['--browser-executable-path', chrome]) + + # Common options + cmd.extend([ + '--browser-headless', + ]) + + # SSL handling + if not check_ssl: + cmd.append('--browser-ignore-insecure-certs') + + if user_agent: + cmd.extend(['--browser-user-agent', user_agent]) + + if cookies_file and Path(cookies_file).is_file(): + cmd.extend(['--browser-cookies-file', cookies_file]) + + if extra_args: + cmd.extend(extra_args.split()) + + # Create output directory + output_dir = Path(OUTPUT_DIR) + output_dir.mkdir(exist_ok=True) + output_path = output_dir / OUTPUT_FILE + + cmd.extend([url, str(output_path)]) + + try: + result = subprocess.run(cmd, capture_output=True, timeout=timeout) + + if output_path.exists() and output_path.stat().st_size > 0: + return True, str(output_path), '' + else: + stderr = result.stderr.decode('utf-8', errors='replace') + if 'ERR_NAME_NOT_RESOLVED' in stderr: + return False, None, 'DNS resolution failed' + if 'ERR_CONNECTION_REFUSED' in stderr: + return False, None, 'Connection refused' + return False, None, f'SingleFile failed: {stderr[:200]}' + + except subprocess.TimeoutExpired: + return False, None, f'Timed out after {timeout} seconds' + except Exception as e: + return False, None, f'{type(e).__name__}: {e}' + + +@click.command() +@click.option('--url', required=True, help='URL to archive') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Archive a URL using SingleFile.""" + + start_ts = datetime.now(timezone.utc) + version = '' + output = None + status = 'failed' + error = '' + binary = None + cmd_str = '' + + try: + # Check if SingleFile is enabled + if not get_env_bool('SAVE_SINGLEFILE', True): + print('Skipping SingleFile (SAVE_SINGLEFILE=False)') + status = 'skipped' + end_ts = datetime.now(timezone.utc) + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'STATUS={status}') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": status, "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) + + # Check if staticfile extractor already handled this (permanent skip) + if has_staticfile_output(): + print(f'Skipping SingleFile - staticfile extractor already downloaded this') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - staticfile already handled + + # Find binary + binary = find_singlefile() + if not binary: + print(f'ERROR: SingleFile binary not found', file=sys.stderr) + print(f'DEPENDENCY_NEEDED={BIN_NAME}', file=sys.stderr) + print(f'BIN_PROVIDERS={BIN_PROVIDERS}', file=sys.stderr) + print(f'INSTALL_HINT=npm install -g single-file-cli', file=sys.stderr) + sys.exit(1) + + version = get_version(binary) + cmd_str = f'{binary} {url} {OUTPUT_DIR}/{OUTPUT_FILE}' + + # Run extraction + success, output, error = save_singlefile(url, binary) + status = 'succeeded' if success else 'failed' + + if success and output: + size = Path(output).stat().st_size + print(f'SingleFile saved ({size} bytes)') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if cmd_str: + print(f'CMD={cmd_str}') + if version: + print(f'VERSION={version}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'cmd_version': version, + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/singlefile/tests/test_archiving.py b/archivebox/plugins/singlefile/tests/test_archiving.py new file mode 100644 index 00000000..b2efd53d --- /dev/null +++ b/archivebox/plugins/singlefile/tests/test_archiving.py @@ -0,0 +1,110 @@ +""" +Integration tests - archive example.com with SingleFile and verify output +""" + +import json +import os +import subprocess +import tempfile +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +INSTALL_SCRIPT = PLUGIN_DIR / "on_Snapshot__04_singlefile.js" +TEST_URL = "https://example.com" + + +# Check if single-file CLI is available +try: + result = subprocess.run( + ["which", "single-file"], + capture_output=True, + timeout=5 + ) + SINGLEFILE_CLI_AVAILABLE = result.returncode == 0 +except: + SINGLEFILE_CLI_AVAILABLE = False + + +@pytest.mark.skipif( + not SINGLEFILE_CLI_AVAILABLE, + reason="single-file CLI not installed (npm install -g single-file-cli)" +) +def test_archives_example_com(): + """Archive example.com and verify output contains expected content""" + + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "singlefile" + output_dir.mkdir() + + output_file = output_dir / "singlefile.html" + + # Run single-file CLI + result = subprocess.run( + [ + "single-file", + "--browser-headless", + TEST_URL, + str(output_file) + ], + capture_output=True, + text=True, + timeout=120 + ) + + assert result.returncode == 0, f"Archive failed: {result.stderr}" + + # Verify output exists + assert output_file.exists(), "Output file not created" + + # Read and verify content + html_content = output_file.read_text() + file_size = output_file.stat().st_size + + # Should be substantial (embedded resources) + assert file_size > 900, f"Output too small: {file_size} bytes" + + # Verify HTML structure (SingleFile minifies, so tag may be omitted) + assert "" in html_content.lower() or "title>" in html_content.lower() + + # Verify example.com content is actually present + assert "example domain" in html_content.lower(), "Missing 'Example Domain' title" + assert "this domain is" in html_content.lower(), "Missing example.com description text" + assert "iana.org" in html_content.lower(), "Missing IANA link" + + # Verify it's not just empty/error page + assert file_size > 900, f"File too small: {file_size} bytes" + + +@pytest.mark.skipif(not SINGLEFILE_CLI_AVAILABLE, reason="single-file CLI not installed") +def test_different_urls_produce_different_outputs(): + """Verify different URLs produce different archived content""" + + with tempfile.TemporaryDirectory() as tmpdir: + outputs = {} + + for url in ["https://example.com", "https://example.org"]: + output_file = Path(tmpdir) / f"{url.replace('https://', '').replace('.', '_')}.html" + + result = subprocess.run( + ["single-file", "--browser-headless", url, str(output_file)], + capture_output=True, + timeout=120 + ) + + if result.returncode == 0 and output_file.exists(): + outputs[url] = output_file.read_text() + + assert len(outputs) == 2, "Should archive both URLs" + + # Verify outputs differ + urls = list(outputs.keys()) + assert outputs[urls[0]] != outputs[urls[1]], "Different URLs should produce different outputs" + + # Each should contain its domain + assert "example.com" in outputs[urls[0]] + assert "example.org" in outputs[urls[1]] diff --git a/archivebox/plugins/singlefile/tests/test_singlefile.js b/archivebox/plugins/singlefile/tests/test_singlefile.js new file mode 100644 index 00000000..fae40036 --- /dev/null +++ b/archivebox/plugins/singlefile/tests/test_singlefile.js @@ -0,0 +1,385 @@ +/** + * Unit tests for singlefile plugin + * + * Run with: node --test tests/test_singlefile.js + */ + +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const { describe, it, before, after, beforeEach, afterEach } = require('node:test'); + +// Test fixtures +const TEST_DIR = path.join(__dirname, '.test_fixtures'); +const TEST_EXTENSIONS_DIR = path.join(TEST_DIR, 'chrome_extensions'); +const TEST_DOWNLOADS_DIR = path.join(TEST_DIR, 'chrome_downloads'); + +describe('singlefile plugin', () => { + before(() => { + if (!fs.existsSync(TEST_DIR)) { + fs.mkdirSync(TEST_DIR, { recursive: true }); + } + }); + + after(() => { + if (fs.existsSync(TEST_DIR)) { + fs.rmSync(TEST_DIR, { recursive: true, force: true }); + } + }); + + describe('EXTENSION metadata', () => { + it('should have correct webstore_id', () => { + const { EXTENSION } = require('../on_Snapshot__04_singlefile.js'); + + assert.strictEqual(EXTENSION.webstore_id, 'mpiodijhokgodhhofbcjdecpffjipkle'); + }); + + it('should have correct name', () => { + const { EXTENSION } = require('../on_Snapshot__04_singlefile.js'); + + assert.strictEqual(EXTENSION.name, 'singlefile'); + }); + }); + + describe('installSinglefileExtension', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should use cached extension if available', async () => { + const { installSinglefileExtension } = require('../on_Snapshot__04_singlefile.js'); + + // Create fake cache + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'singlefile.extension.json'); + const fakeExtensionDir = path.join(TEST_EXTENSIONS_DIR, 'fake_singlefile'); + + fs.mkdirSync(fakeExtensionDir, { recursive: true }); + fs.writeFileSync( + path.join(fakeExtensionDir, 'manifest.json'), + JSON.stringify({ version: '1.22.90' }) + ); + + const fakeCache = { + webstore_id: 'mpiodijhokgodhhofbcjdecpffjipkle', + name: 'singlefile', + unpacked_path: fakeExtensionDir, + version: '1.22.90' + }; + + fs.writeFileSync(cacheFile, JSON.stringify(fakeCache)); + + const result = await installSinglefileExtension(); + + assert.notStrictEqual(result, null); + assert.strictEqual(result.webstore_id, 'mpiodijhokgodhhofbcjdecpffjipkle'); + }); + }); + + describe('saveSinglefileWithExtension', () => { + beforeEach(() => { + process.env.CHROME_DOWNLOADS_DIR = TEST_DOWNLOADS_DIR; + + if (!fs.existsSync(TEST_DOWNLOADS_DIR)) { + fs.mkdirSync(TEST_DOWNLOADS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_DOWNLOADS_DIR)) { + fs.rmSync(TEST_DOWNLOADS_DIR, { recursive: true }); + } + + delete process.env.CHROME_DOWNLOADS_DIR; + }); + + it('should require extension and version to be present', () => { + const mockExtension = { + name: 'singlefile', + version: '1.22.96', + id: 'test_id' + }; + + assert.ok(mockExtension.version); + assert.ok(mockExtension.id); + }); + + it('should filter unsupported URL schemes', () => { + const unsupportedSchemes = [ + 'about:', + 'chrome:', + 'chrome-extension:', + 'data:', + 'javascript:', + 'blob:' + ]; + + unsupportedSchemes.forEach(scheme => { + const testUrl = scheme + 'something'; + const urlScheme = testUrl.split(':')[0]; + + assert.ok(unsupportedSchemes.some(s => s.startsWith(urlScheme))); + }); + }); + + it('should wait for file to appear in downloads directory', async () => { + const checkDelay = 3000; // 3 seconds + const maxTries = 10; + + // Total max wait time + const maxWaitTime = checkDelay * maxTries; + + assert.strictEqual(maxWaitTime, 30000); // 30 seconds + }); + + it('should find downloaded file by checking URL in HTML header', () => { + const testUrl = 'https://example.com'; + const mockHtml = ``; + + // Should be able to extract URL from header + const headerPart = mockHtml.split('meta charset')[0]; + assert.ok(headerPart.includes(`url: ${testUrl}`)); + }); + + it('should move file from downloads to output directory', () => { + const downloadPath = path.join(TEST_DOWNLOADS_DIR, 'temp_file.html'); + const outputDir = 'singlefile'; + const outputFile = 'singlefile.html'; + const outputPath = path.join(outputDir, outputFile); + + // Verify paths are different + assert.notStrictEqual(downloadPath, outputPath); + }); + }); + + describe('saveSinglefileWithCLI', () => { + it('should use single-file-cli as fallback', () => { + const cliCommand = 'single-file'; + + // Should check for CLI availability + assert.strictEqual(typeof cliCommand, 'string'); + assert.ok(cliCommand.length > 0); + }); + + it('should pass correct arguments to CLI', () => { + const args = [ + '--browser-headless', + 'https://example.com', + 'singlefile/singlefile.html' + ]; + + assert.ok(args.includes('--browser-headless')); + assert.ok(args.some(arg => arg.startsWith('http'))); + }); + + it('should handle optional CLI arguments', () => { + const options = { + userAgent: 'Mozilla/5.0...', + cookiesFile: '/path/to/cookies.txt', + ignoreSSL: true + }; + + // Optional args should be conditionally added + if (options.userAgent) { + assert.ok(options.userAgent.length > 0); + } + + if (options.ignoreSSL) { + assert.strictEqual(options.ignoreSSL, true); + } + }); + }); + + describe('priority and execution order', () => { + it('should have priority 04 (early)', () => { + const filename = 'on_Snapshot__04_singlefile.js'; + + const match = filename.match(/on_Snapshot__(\d+)_/); + assert.ok(match); + + const priority = parseInt(match[1]); + assert.strictEqual(priority, 4); + }); + + it('should run before chrome_session (priority 20)', () => { + const extensionPriority = 4; + const chromeSessionPriority = 20; + + assert.ok(extensionPriority < chromeSessionPriority); + }); + + it('should install extensions in correct order', () => { + const priorities = { + captcha2: 1, + istilldontcareaboutcookies: 2, + ublock: 3, + singlefile: 4 + }; + + // Should be in ascending order + assert.ok(priorities.captcha2 < priorities.istilldontcareaboutcookies); + assert.ok(priorities.istilldontcareaboutcookies < priorities.ublock); + assert.ok(priorities.ublock < priorities.singlefile); + }); + }); + + describe('output structure', () => { + it('should define output directory and file', () => { + const OUTPUT_DIR = 'singlefile'; + const OUTPUT_FILE = 'singlefile.html'; + + assert.strictEqual(OUTPUT_DIR, 'singlefile'); + assert.strictEqual(OUTPUT_FILE, 'singlefile.html'); + }); + + it('should create output directory if not exists', () => { + const outputDir = path.join(TEST_DIR, 'singlefile'); + + // Should create directory + if (!fs.existsSync(outputDir)) { + fs.mkdirSync(outputDir, { recursive: true }); + } + + assert.ok(fs.existsSync(outputDir)); + + // Cleanup + fs.rmSync(outputDir, { recursive: true }); + }); + }); + + describe('extension vs CLI fallback', () => { + it('should prefer extension over CLI', () => { + const preferenceOrder = [ + 'extension', + 'cli' + ]; + + assert.strictEqual(preferenceOrder[0], 'extension'); + assert.strictEqual(preferenceOrder[1], 'cli'); + }); + + it('should fallback to CLI if extension unavailable', () => { + const extensionAvailable = false; + const cliAvailable = true; + + let method; + if (extensionAvailable) { + method = 'extension'; + } else if (cliAvailable) { + method = 'cli'; + } + + assert.strictEqual(method, 'cli'); + }); + + it('should use extension if available', () => { + const extensionAvailable = true; + + let method; + if (extensionAvailable) { + method = 'extension'; + } else { + method = 'cli'; + } + + assert.strictEqual(method, 'extension'); + }); + }); + + describe('file matching and validation', () => { + beforeEach(() => { + if (!fs.existsSync(TEST_DOWNLOADS_DIR)) { + fs.mkdirSync(TEST_DOWNLOADS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_DOWNLOADS_DIR)) { + fs.rmSync(TEST_DOWNLOADS_DIR, { recursive: true }); + } + }); + + it('should filter HTML files from downloads', () => { + // Create mock download files + const files = [ + 'example.html', + 'test.pdf', + 'image.png', + 'page.html' + ]; + + const htmlFiles = files.filter(f => f.endsWith('.html')); + + assert.strictEqual(htmlFiles.length, 2); + assert.ok(htmlFiles.includes('example.html')); + assert.ok(htmlFiles.includes('page.html')); + }); + + it('should match URL in HTML header comment', () => { + const testUrl = 'https://example.com/page'; + + const htmlContent = ` +...`; + + const headerSection = htmlContent.split('meta charset')[0] || htmlContent.split('')[0]; + + assert.ok(headerSection.includes(`url: ${testUrl}`)); + }); + + it('should handle multiple new files in downloads', () => { + const filesBefore = new Set(['old1.html', 'old2.html']); + const filesAfter = ['old1.html', 'old2.html', 'new1.html', 'new2.html']; + + const filesNew = filesAfter.filter(f => !filesBefore.has(f)); + + assert.strictEqual(filesNew.length, 2); + assert.ok(filesNew.includes('new1.html')); + assert.ok(filesNew.includes('new2.html')); + }); + }); + + describe('error handling', () => { + it('should timeout after max wait time', () => { + const checkDelay = 3000; // ms + const maxTries = 10; + const timeoutMs = checkDelay * maxTries; + + assert.strictEqual(timeoutMs, 30000); // 30 seconds + }); + + it('should handle missing extension gracefully', () => { + const extension = null; + + if (!extension || !extension.version) { + // Should throw error + assert.ok(true); + } + }); + + it('should handle file not found after waiting', () => { + const filesNew = []; + const maxWaitReached = true; + + if (filesNew.length === 0 && maxWaitReached) { + // Should return null + const result = null; + assert.strictEqual(result, null); + } + }); + }); +}); diff --git a/archivebox/plugins/singlefile/tests/test_singlefile.py b/archivebox/plugins/singlefile/tests/test_singlefile.py new file mode 100644 index 00000000..0a4f4ee8 --- /dev/null +++ b/archivebox/plugins/singlefile/tests/test_singlefile.py @@ -0,0 +1,141 @@ +""" +Unit tests for singlefile plugin + +Tests invoke the plugin hook as an external process and verify outputs/side effects. +""" + +import json +import os +import subprocess +import tempfile +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +INSTALL_SCRIPT = PLUGIN_DIR / "on_Snapshot__04_singlefile.js" + + +def test_install_script_exists(): + """Verify install script exists""" + assert INSTALL_SCRIPT.exists(), f"Install script not found: {INSTALL_SCRIPT}" + + +def test_extension_metadata(): + """Test that SingleFile extension has correct metadata""" + with tempfile.TemporaryDirectory() as tmpdir: + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(Path(tmpdir) / "chrome_extensions") + + result = subprocess.run( + ["node", "-e", f"const ext = require('{INSTALL_SCRIPT}'); console.log(JSON.stringify(ext.EXTENSION))"], + capture_output=True, + text=True, + env=env + ) + + assert result.returncode == 0, f"Failed to load extension metadata: {result.stderr}" + + metadata = json.loads(result.stdout) + assert metadata["webstore_id"] == "mpiodijhokgodhhofbcjdecpffjipkle" + assert metadata["name"] == "singlefile" + + +def test_install_creates_cache(): + """Test that install creates extension cache""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=60 + ) + + # Check output mentions installation + assert "SingleFile" in result.stdout or "singlefile" in result.stdout + + # Check cache file was created + cache_file = ext_dir / "singlefile.extension.json" + assert cache_file.exists(), "Cache file should be created" + + # Verify cache content + cache_data = json.loads(cache_file.read_text()) + assert cache_data["webstore_id"] == "mpiodijhokgodhhofbcjdecpffjipkle" + assert cache_data["name"] == "singlefile" + + +def test_install_uses_existing_cache(): + """Test that install uses existing cache when available""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + # Create fake cache + fake_extension_dir = ext_dir / "mpiodijhokgodhhofbcjdecpffjipkle__singlefile" + fake_extension_dir.mkdir(parents=True) + + manifest = {"version": "1.22.96", "name": "SingleFile"} + (fake_extension_dir / "manifest.json").write_text(json.dumps(manifest)) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Should use cache or install successfully + assert result.returncode == 0 + + +def test_no_configuration_required(): + """Test that SingleFile works without configuration""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + # No API keys needed + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=60 + ) + + # Should work without API keys + assert result.returncode == 0 + + +def test_priority_order(): + """Test that singlefile has correct priority (04)""" + # Extract priority from filename + filename = INSTALL_SCRIPT.name + assert "04" in filename, "SingleFile should have priority 04" + assert filename.startswith("on_Snapshot__04_"), "Should follow priority naming convention" + + +def test_output_directory_structure(): + """Test that plugin defines correct output structure""" + # Verify the script mentions singlefile output directory + script_content = INSTALL_SCRIPT.read_text() + + # Should mention singlefile output directory + assert "singlefile" in script_content.lower() + # Should mention HTML output + assert ".html" in script_content or "html" in script_content.lower() diff --git a/archivebox/plugins/ssl/on_Snapshot__23_ssl.js b/archivebox/plugins/ssl/on_Snapshot__23_ssl.js new file mode 100755 index 00000000..78e7592e --- /dev/null +++ b/archivebox/plugins/ssl/on_Snapshot__23_ssl.js @@ -0,0 +1,243 @@ +#!/usr/bin/env node +/** + * Extract SSL/TLS certificate details from a URL. + * + * Connects to Chrome session and retrieves security details including: + * - Protocol (TLS 1.2, TLS 1.3, etc.) + * - Cipher suite + * - Certificate issuer, validity period + * - Security state + * + * Usage: on_Snapshot__16_ssl.js --url= --snapshot-id= + * Output: Writes ssl/ssl.json + * + * Environment variables: + * SAVE_SSL: Enable SSL extraction (default: true) + */ + +const fs = require('fs'); +const path = require('path'); +const puppeteer = require('puppeteer-core'); + +// Extractor metadata +const EXTRACTOR_NAME = 'ssl'; +const OUTPUT_DIR = 'ssl'; +const OUTPUT_FILE = 'ssl.json'; +const CHROME_SESSION_DIR = 'chrome_session'; + +// Parse command line arguments +function parseArgs() { + const args = {}; + process.argv.slice(2).forEach(arg => { + if (arg.startsWith('--')) { + const [key, ...valueParts] = arg.slice(2).split('='); + args[key.replace(/-/g, '_')] = valueParts.join('=') || true; + } + }); + return args; +} + +// Get environment variable with default +function getEnv(name, defaultValue = '') { + return (process.env[name] || defaultValue).trim(); +} + +function getEnvBool(name, defaultValue = false) { + const val = getEnv(name, '').toLowerCase(); + if (['true', '1', 'yes', 'on'].includes(val)) return true; + if (['false', '0', 'no', 'off'].includes(val)) return false; + return defaultValue; +} + +// Get CDP URL from chrome_session +function getCdpUrl() { + const cdpFile = path.join(CHROME_SESSION_DIR, 'cdp_url.txt'); + if (fs.existsSync(cdpFile)) { + return fs.readFileSync(cdpFile, 'utf8').trim(); + } + return null; +} + +// Extract SSL details +async function extractSsl(url) { + // Create output directory + if (!fs.existsSync(OUTPUT_DIR)) { + fs.mkdirSync(OUTPUT_DIR, { recursive: true }); + } + const outputPath = path.join(OUTPUT_DIR, OUTPUT_FILE); + + // Only extract SSL for HTTPS URLs + if (!url.startsWith('https://')) { + return { success: false, error: 'URL is not HTTPS' }; + } + + let browser = null; + let sslInfo = {}; + + try { + // Connect to existing Chrome session + const cdpUrl = getCdpUrl(); + if (!cdpUrl) { + return { success: false, error: 'No Chrome session found (chrome_session extractor must run first)' }; + } + + browser = await puppeteer.connect({ + browserWSEndpoint: cdpUrl, + }); + + // Get the page + const pages = await browser.pages(); + const page = pages.find(p => p.url().startsWith('http')) || pages[0]; + + if (!page) { + return { success: false, error: 'No page found in Chrome session' }; + } + + // Get CDP client for low-level access + const client = await page.target().createCDPSession(); + + // Enable Security domain + await client.send('Security.enable'); + + // Get security details from the loaded page + const securityState = await client.send('Security.getSecurityState'); + + sslInfo = { + url, + securityState: securityState.securityState, + schemeIsCryptographic: securityState.schemeIsCryptographic, + summary: securityState.summary || '', + }; + + // Try to get detailed certificate info if available + if (securityState.securityStateIssueIds && securityState.securityStateIssueIds.length > 0) { + sslInfo.issues = securityState.securityStateIssueIds; + } + + // Get response security details from navigation + let mainResponse = null; + page.on('response', async (response) => { + if (response.url() === url || response.request().isNavigationRequest()) { + mainResponse = response; + } + }); + + // If we have security details from response + if (mainResponse) { + try { + const securityDetails = await mainResponse.securityDetails(); + if (securityDetails) { + sslInfo.protocol = securityDetails.protocol(); + sslInfo.subjectName = securityDetails.subjectName(); + sslInfo.issuer = securityDetails.issuer(); + sslInfo.validFrom = securityDetails.validFrom(); + sslInfo.validTo = securityDetails.validTo(); + sslInfo.certificateId = securityDetails.subjectName(); + + const sanList = securityDetails.sanList(); + if (sanList && sanList.length > 0) { + sslInfo.subjectAlternativeNames = sanList; + } + } + } catch (e) { + // Security details not available + } + } + + await client.detach(); + + // Write output + fs.writeFileSync(outputPath, JSON.stringify(sslInfo, null, 2)); + + return { success: true, output: outputPath, sslInfo }; + + } catch (e) { + return { success: false, error: `${e.name}: ${e.message}` }; + } finally { + if (browser) { + browser.disconnect(); + } + } +} + +async function main() { + const args = parseArgs(); + const url = args.url; + const snapshotId = args.snapshot_id; + + if (!url || !snapshotId) { + console.error('Usage: on_Snapshot__16_ssl.js --url= --snapshot-id='); + process.exit(1); + } + + const startTs = new Date(); + let status = 'failed'; + let output = null; + let error = ''; + + try { + // Check if enabled + if (!getEnvBool('SAVE_SSL', true)) { + console.log('Skipping SSL (SAVE_SSL=False)'); + status = 'skipped'; + const endTs = new Date(); + console.log(`START_TS=${startTs.toISOString()}`); + console.log(`END_TS=${endTs.toISOString()}`); + console.log(`STATUS=${status}`); + console.log(`RESULT_JSON=${JSON.stringify({extractor: EXTRACTOR_NAME, status, url, snapshot_id: snapshotId})}`); + process.exit(0); + } + + const result = await extractSsl(url); + + if (result.success) { + status = 'succeeded'; + output = result.output; + const protocol = result.sslInfo?.protocol || 'unknown'; + console.log(`SSL details extracted: ${protocol}`); + } else { + status = 'failed'; + error = result.error; + } + } catch (e) { + error = `${e.name}: ${e.message}`; + status = 'failed'; + } + + const endTs = new Date(); + const duration = (endTs - startTs) / 1000; + + // Print results + console.log(`START_TS=${startTs.toISOString()}`); + console.log(`END_TS=${endTs.toISOString()}`); + console.log(`DURATION=${duration.toFixed(2)}`); + if (output) { + console.log(`OUTPUT=${output}`); + } + console.log(`STATUS=${status}`); + + if (error) { + console.error(`ERROR=${error}`); + } + + // Print JSON result + const resultJson = { + extractor: EXTRACTOR_NAME, + url, + snapshot_id: snapshotId, + status, + start_ts: startTs.toISOString(), + end_ts: endTs.toISOString(), + duration: Math.round(duration * 100) / 100, + output, + error: error || null, + }; + console.log(`RESULT_JSON=${JSON.stringify(resultJson)}`); + + process.exit(status === 'succeeded' ? 0 : 1); +} + +main().catch(e => { + console.error(`Fatal error: ${e.message}`); + process.exit(1); +}); diff --git a/archivebox/plugins/staticfile/on_Snapshot__31_staticfile.py b/archivebox/plugins/staticfile/on_Snapshot__31_staticfile.py new file mode 100644 index 00000000..237f2d82 --- /dev/null +++ b/archivebox/plugins/staticfile/on_Snapshot__31_staticfile.py @@ -0,0 +1,337 @@ +#!/usr/bin/env python3 +""" +Download static files (PDFs, images, archives, etc.) directly. + +This extractor runs AFTER chrome_session and checks the Content-Type header +from chrome_session/response_headers.json to determine if the URL points to +a static file that should be downloaded directly. + +Other extractors check for the presence of this extractor's output directory +to know if they should skip (since Chrome-based extractors can't meaningfully +process static files like PDFs, images, etc.). + +Usage: on_Snapshot__21_staticfile.py --url= --snapshot-id= +Output: Downloads file to staticfile/ + +Environment variables: + STATICFILE_TIMEOUT: Timeout in seconds (default: 300) + STATICFILE_MAX_SIZE: Maximum file size in bytes (default: 1GB) + USER_AGENT: User agent string (optional) + CHECK_SSL_VALIDITY: Whether to check SSL certificates (default: True) +""" + +import json +import os +import sys +from datetime import datetime, timezone +from pathlib import Path +from urllib.parse import urlparse, unquote + +import rich_click as click + +# Extractor metadata +EXTRACTOR_NAME = 'staticfile' +OUTPUT_DIR = 'staticfile' +CHROME_SESSION_DIR = 'chrome_session' + +# Content-Types that indicate static files +# These can't be meaningfully processed by Chrome-based extractors +STATIC_CONTENT_TYPES = { + # Documents + 'application/pdf', + 'application/msword', + 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', + 'application/vnd.ms-excel', + 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', + 'application/vnd.ms-powerpoint', + 'application/vnd.openxmlformats-officedocument.presentationml.presentation', + 'application/rtf', + 'application/epub+zip', + # Images + 'image/png', + 'image/jpeg', + 'image/gif', + 'image/webp', + 'image/svg+xml', + 'image/x-icon', + 'image/bmp', + 'image/tiff', + 'image/avif', + 'image/heic', + 'image/heif', + # Audio + 'audio/mpeg', + 'audio/mp3', + 'audio/wav', + 'audio/flac', + 'audio/aac', + 'audio/ogg', + 'audio/webm', + 'audio/m4a', + 'audio/opus', + # Video + 'video/mp4', + 'video/webm', + 'video/x-matroska', + 'video/avi', + 'video/quicktime', + 'video/x-ms-wmv', + 'video/x-flv', + # Archives + 'application/zip', + 'application/x-tar', + 'application/gzip', + 'application/x-bzip2', + 'application/x-xz', + 'application/x-7z-compressed', + 'application/x-rar-compressed', + 'application/vnd.rar', + # Data + 'application/json', + 'application/xml', + 'text/csv', + 'text/xml', + 'application/x-yaml', + # Executables/Binaries + 'application/octet-stream', # Generic binary + 'application/x-executable', + 'application/x-msdos-program', + 'application/x-apple-diskimage', + 'application/vnd.debian.binary-package', + 'application/x-rpm', + # Other + 'application/x-bittorrent', + 'application/wasm', +} + +# Also check Content-Type prefixes for categories +STATIC_CONTENT_TYPE_PREFIXES = ( + 'image/', + 'audio/', + 'video/', + 'application/zip', + 'application/x-', +) + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +def get_content_type_from_chrome_session() -> str | None: + """Read Content-Type from chrome_session's response headers.""" + headers_file = Path(CHROME_SESSION_DIR) / 'response_headers.json' + if not headers_file.exists(): + return None + + try: + with open(headers_file) as f: + headers = json.load(f) + # Headers might be nested or flat depending on chrome_session format + content_type = headers.get('content-type') or headers.get('Content-Type') or '' + # Strip charset and other parameters + return content_type.split(';')[0].strip().lower() + except Exception: + return None + + +def is_static_content_type(content_type: str) -> bool: + """Check if Content-Type indicates a static file.""" + if not content_type: + return False + + # Check exact match + if content_type in STATIC_CONTENT_TYPES: + return True + + # Check prefixes + for prefix in STATIC_CONTENT_TYPE_PREFIXES: + if content_type.startswith(prefix): + return True + + return False + + +def get_filename_from_url(url: str) -> str: + """Extract filename from URL.""" + parsed = urlparse(url) + path = unquote(parsed.path) + filename = path.split('/')[-1] or 'downloaded_file' + + # Sanitize filename + filename = filename.replace('/', '_').replace('\\', '_') + if len(filename) > 200: + filename = filename[:200] + + return filename + + +def download_file(url: str) -> tuple[bool, str | None, str]: + """ + Download a static file. + + Returns: (success, output_path, error_message) + """ + import requests + + timeout = get_env_int('STATICFILE_TIMEOUT', 300) + max_size = get_env_int('STATICFILE_MAX_SIZE', 1024 * 1024 * 1024) # 1GB default + user_agent = get_env('USER_AGENT', 'Mozilla/5.0 (compatible; ArchiveBox/1.0)') + check_ssl = get_env_bool('CHECK_SSL_VALIDITY', True) + + headers = {'User-Agent': user_agent} + + try: + # Stream download to handle large files + response = requests.get( + url, + headers=headers, + timeout=timeout, + stream=True, + verify=check_ssl, + allow_redirects=True, + ) + response.raise_for_status() + + # Check content length if available + content_length = response.headers.get('content-length') + if content_length and int(content_length) > max_size: + return False, None, f'File too large: {int(content_length)} bytes > {max_size} max' + + # Create output directory + output_dir = Path(OUTPUT_DIR) + output_dir.mkdir(exist_ok=True) + + # Determine filename + filename = get_filename_from_url(url) + + # Check content-disposition header for better filename + content_disp = response.headers.get('content-disposition', '') + if 'filename=' in content_disp: + import re + match = re.search(r'filename[*]?=["\']?([^"\';\n]+)', content_disp) + if match: + filename = match.group(1).strip() + + output_path = output_dir / filename + + # Download in chunks + downloaded_size = 0 + with open(output_path, 'wb') as f: + for chunk in response.iter_content(chunk_size=8192): + if chunk: + downloaded_size += len(chunk) + if downloaded_size > max_size: + f.close() + output_path.unlink() + return False, None, f'File too large: exceeded {max_size} bytes' + f.write(chunk) + + return True, str(output_path), '' + + except requests.exceptions.Timeout: + return False, None, f'Timed out after {timeout} seconds' + except requests.exceptions.SSLError as e: + return False, None, f'SSL error: {e}' + except requests.exceptions.RequestException as e: + return False, None, f'Download failed: {e}' + except Exception as e: + return False, None, f'{type(e).__name__}: {e}' + + +@click.command() +@click.option('--url', required=True, help='URL to download') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Download static files based on Content-Type from chrome_session.""" + + start_ts = datetime.now(timezone.utc) + output = None + status = 'failed' + error = '' + + # Check Content-Type from chrome_session's response headers + content_type = get_content_type_from_chrome_session() + + # If chrome_session didn't run or no Content-Type, skip + if not content_type: + print(f'No Content-Type found (chrome_session may not have run)') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - can't determine content type + + # If not a static file type, skip (this is the normal case for HTML pages) + if not is_static_content_type(content_type): + print(f'Not a static file (Content-Type: {content_type})') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id, "content_type": content_type})}') + sys.exit(0) # Permanent skip - not a static file + + try: + # Download the file + print(f'Static file detected (Content-Type: {content_type}), downloading...') + success, output, error = download_file(url) + status = 'succeeded' if success else 'failed' + + if success and output: + size = Path(output).stat().st_size + print(f'Static file downloaded ({size} bytes): {output}') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'content_type': content_type, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/title/on_Snapshot__32_title.js b/archivebox/plugins/title/on_Snapshot__32_title.js new file mode 100644 index 00000000..afc60fb8 --- /dev/null +++ b/archivebox/plugins/title/on_Snapshot__32_title.js @@ -0,0 +1,262 @@ +#!/usr/bin/env node +/** + * Extract the title of a URL. + * + * If a Chrome session exists (from chrome_session extractor), connects to it via CDP + * to get the page title (which includes JS-rendered content). + * Otherwise falls back to fetching the URL and parsing HTML. + * + * Usage: on_Snapshot__10_title.js --url= --snapshot-id= + * Output: Writes title/title.txt + * + * Environment variables: + * TIMEOUT: Timeout in seconds (default: 30) + * USER_AGENT: User agent string (optional) + */ + +const fs = require('fs'); +const path = require('path'); +const https = require('https'); +const http = require('http'); + +// Extractor metadata +const EXTRACTOR_NAME = 'title'; +const OUTPUT_DIR = 'title'; +const OUTPUT_FILE = 'title.txt'; +const CHROME_SESSION_DIR = 'chrome_session'; + +// Parse command line arguments +function parseArgs() { + const args = {}; + process.argv.slice(2).forEach(arg => { + if (arg.startsWith('--')) { + const [key, ...valueParts] = arg.slice(2).split('='); + args[key.replace(/-/g, '_')] = valueParts.join('=') || true; + } + }); + return args; +} + +// Get environment variable with default +function getEnv(name, defaultValue = '') { + return (process.env[name] || defaultValue).trim(); +} + +function getEnvInt(name, defaultValue = 0) { + const val = parseInt(getEnv(name, String(defaultValue)), 10); + return isNaN(val) ? defaultValue : val; +} + +// Get CDP URL from chrome_session if available +function getCdpUrl() { + const cdpFile = path.join(CHROME_SESSION_DIR, 'cdp_url.txt'); + if (fs.existsSync(cdpFile)) { + return fs.readFileSync(cdpFile, 'utf8').trim(); + } + return null; +} + +// Extract title from HTML +function extractTitleFromHtml(html) { + // Try tag + const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i); + if (titleMatch) { + return titleMatch[1].trim(); + } + + // Try og:title + const ogMatch = html.match(/<meta[^>]+property=["']og:title["'][^>]+content=["']([^"']+)["']/i); + if (ogMatch) { + return ogMatch[1].trim(); + } + + // Try twitter:title + const twitterMatch = html.match(/<meta[^>]+name=["']twitter:title["'][^>]+content=["']([^"']+)["']/i); + if (twitterMatch) { + return twitterMatch[1].trim(); + } + + return null; +} + +// Fetch URL and extract title (fallback method) +function fetchTitle(url) { + return new Promise((resolve, reject) => { + const timeout = getEnvInt('TIMEOUT', 30) * 1000; + const userAgent = getEnv('USER_AGENT', 'Mozilla/5.0 (compatible; ArchiveBox/1.0)'); + + const client = url.startsWith('https') ? https : http; + + const req = client.get(url, { + headers: { 'User-Agent': userAgent }, + timeout, + }, (res) => { + // Handle redirects + if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) { + fetchTitle(res.headers.location).then(resolve).catch(reject); + return; + } + + let data = ''; + res.on('data', chunk => { + data += chunk; + // Only need first 64KB to find title + if (data.length > 65536) { + req.destroy(); + } + }); + res.on('end', () => { + const title = extractTitleFromHtml(data); + if (title) { + resolve(title); + } else { + reject(new Error('No title found in HTML')); + } + }); + }); + + req.on('error', reject); + req.on('timeout', () => { + req.destroy(); + reject(new Error('Request timeout')); + }); + }); +} + +// Get title using Puppeteer CDP connection +async function getTitleFromCdp(cdpUrl) { + const puppeteer = require('puppeteer-core'); + + const browser = await puppeteer.connect({ + browserWSEndpoint: cdpUrl, + }); + + try { + // Get existing pages + const pages = await browser.pages(); + const page = pages.find(p => p.url().startsWith('http')) || pages[0]; + + if (!page) { + throw new Error('No page found in Chrome session'); + } + + // Get title from page + const title = await page.title(); + + if (!title) { + // Try getting from DOM directly + const domTitle = await page.evaluate(() => { + return document.title || + document.querySelector('meta[property="og:title"]')?.content || + document.querySelector('meta[name="twitter:title"]')?.content || + document.querySelector('h1')?.textContent?.trim(); + }); + return domTitle; + } + + return title; + } finally { + // Disconnect without closing browser + browser.disconnect(); + } +} + +async function extractTitle(url) { + // Create output directory + if (!fs.existsSync(OUTPUT_DIR)) { + fs.mkdirSync(OUTPUT_DIR, { recursive: true }); + } + const outputPath = path.join(OUTPUT_DIR, OUTPUT_FILE); + + // Try Chrome session first + const cdpUrl = getCdpUrl(); + if (cdpUrl) { + try { + const title = await getTitleFromCdp(cdpUrl); + if (title) { + fs.writeFileSync(outputPath, title, 'utf8'); + return { success: true, output: outputPath, title, method: 'cdp' }; + } + } catch (e) { + console.error(`CDP title extraction failed: ${e.message}, falling back to HTTP`); + } + } + + // Fallback to HTTP fetch + try { + const title = await fetchTitle(url); + fs.writeFileSync(outputPath, title, 'utf8'); + return { success: true, output: outputPath, title, method: 'http' }; + } catch (e) { + return { success: false, error: e.message }; + } +} + +async function main() { + const args = parseArgs(); + const url = args.url; + const snapshotId = args.snapshot_id; + + if (!url || !snapshotId) { + console.error('Usage: on_Snapshot__10_title.js --url=<url> --snapshot-id=<uuid>'); + process.exit(1); + } + + const startTs = new Date(); + let status = 'failed'; + let output = null; + let error = ''; + + try { + const result = await extractTitle(url); + + if (result.success) { + status = 'succeeded'; + output = result.output; + console.log(`Title extracted (${result.method}): ${result.title}`); + } else { + status = 'failed'; + error = result.error; + } + } catch (e) { + error = `${e.name}: ${e.message}`; + status = 'failed'; + } + + const endTs = new Date(); + const duration = (endTs - startTs) / 1000; + + // Print results + console.log(`START_TS=${startTs.toISOString()}`); + console.log(`END_TS=${endTs.toISOString()}`); + console.log(`DURATION=${duration.toFixed(2)}`); + if (output) { + console.log(`OUTPUT=${output}`); + } + console.log(`STATUS=${status}`); + + if (error) { + console.error(`ERROR=${error}`); + } + + // Print JSON result + const resultJson = { + extractor: EXTRACTOR_NAME, + url, + snapshot_id: snapshotId, + status, + start_ts: startTs.toISOString(), + end_ts: endTs.toISOString(), + duration: Math.round(duration * 100) / 100, + output, + error: error || null, + }; + console.log(`RESULT_JSON=${JSON.stringify(resultJson)}`); + + process.exit(status === 'succeeded' ? 0 : 1); +} + +main().catch(e => { + console.error(`Fatal error: ${e.message}`); + process.exit(1); +}); diff --git a/archivebox/plugins/title/tests/test_title.py b/archivebox/plugins/title/tests/test_title.py new file mode 100644 index 00000000..f2eb503e --- /dev/null +++ b/archivebox/plugins/title/tests/test_title.py @@ -0,0 +1,241 @@ +""" +Integration tests for title plugin + +Tests verify: +1. Plugin script exists +2. Node.js is available +3. Title extraction works for real example.com +4. Output file contains actual page title +5. Handles various title sources (<title>, og:title, twitter:title) +6. Config options work (TIMEOUT, USER_AGENT) +7. Fallback to HTTP when chrome_session not available +""" + +import shutil +import subprocess +import tempfile +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +TITLE_HOOK = PLUGIN_DIR / 'on_Snapshot__32_title.js' +TEST_URL = 'https://example.com' + + +def test_hook_script_exists(): + """Verify hook script exists.""" + assert TITLE_HOOK.exists(), f"Hook script not found: {TITLE_HOOK}" + + +def test_extracts_title_from_example_com(): + """Test full workflow: extract title from real example.com.""" + + # Check node is available + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Run title extraction + result = subprocess.run( + ['node', str(TITLE_HOOK), f'--url={TEST_URL}', '--snapshot-id=test789'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + assert result.returncode == 0, f"Extraction failed: {result.stderr}" + + # Verify output in stdout + assert 'STATUS=succeeded' in result.stdout, "Should report success" + assert 'Title extracted' in result.stdout, "Should report completion" + + # Verify output directory created + title_dir = tmpdir / 'title' + assert title_dir.exists(), "Output directory not created" + + # Verify output file exists + title_file = title_dir / 'title.txt' + assert title_file.exists(), "title.txt not created" + + # Verify title contains REAL example.com title + title_text = title_file.read_text().strip() + assert len(title_text) > 0, "Title should not be empty" + assert 'example' in title_text.lower(), "Title should contain 'example'" + + # example.com has title "Example Domain" + assert 'example domain' in title_text.lower(), f"Expected 'Example Domain', got: {title_text}" + + # Verify RESULT_JSON is present + assert 'RESULT_JSON=' in result.stdout, "Should output RESULT_JSON" + + +def test_falls_back_to_http_when_chrome_session_unavailable(): + """Test that title plugin falls back to HTTP when chrome_session unavailable.""" + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Don't create chrome_session directory - force HTTP fallback + + # Run title extraction + result = subprocess.run( + ['node', str(TITLE_HOOK), f'--url={TEST_URL}', '--snapshot-id=testhttp'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + assert result.returncode == 0, f"Extraction failed: {result.stderr}" + assert 'STATUS=succeeded' in result.stdout, "Should report success" + + # Verify output exists and has real title + output_title_file = tmpdir / 'title' / 'title.txt' + assert output_title_file.exists(), "Output title.txt not created" + + title_text = output_title_file.read_text().strip() + assert 'example' in title_text.lower() + + +def test_config_timeout_honored(): + """Test that TIMEOUT config is respected.""" + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set very short timeout (but example.com should still succeed) + import os + env = os.environ.copy() + env['TIMEOUT'] = '5' + + result = subprocess.run( + ['node', str(TITLE_HOOK), f'--url={TEST_URL}', '--snapshot-id=testtimeout'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Should complete (success or fail, but not hang) + assert result.returncode in (0, 1), "Should complete without hanging" + + +def test_config_user_agent(): + """Test that USER_AGENT config is used.""" + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set custom user agent + import os + env = os.environ.copy() + env['USER_AGENT'] = 'TestBot/1.0' + + result = subprocess.run( + ['node', str(TITLE_HOOK), f'--url={TEST_URL}', '--snapshot-id=testua'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=60 + ) + + # Should succeed (example.com doesn't block) + if result.returncode == 0: + assert 'STATUS=succeeded' in result.stdout + + +def test_handles_https_urls(): + """Test that HTTPS URLs work correctly.""" + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + result = subprocess.run( + ['node', str(TITLE_HOOK), '--url=https://example.org', '--snapshot-id=testhttps'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + if result.returncode == 0: + output_title_file = tmpdir / 'title' / 'title.txt' + if output_title_file.exists(): + title_text = output_title_file.read_text().strip() + assert len(title_text) > 0, "Title should not be empty" + assert 'example' in title_text.lower() + + +def test_handles_404_gracefully(): + """Test that title plugin handles 404 pages. + + Note: example.com returns valid HTML even for 404 pages, so extraction may succeed + with the generic "Example Domain" title. + """ + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + result = subprocess.run( + ['node', str(TITLE_HOOK), '--url=https://example.com/nonexistent-page-404', '--snapshot-id=test404'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + # May succeed or fail depending on server behavior + # example.com returns "Example Domain" even for 404s + assert result.returncode in (0, 1), "Should complete (may succeed or fail)" + + +def test_handles_redirects(): + """Test that title plugin handles redirects correctly.""" + + if not shutil.which('node'): + pytest.skip("node not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # http://example.com redirects to https://example.com + result = subprocess.run( + ['node', str(TITLE_HOOK), '--url=http://example.com', '--snapshot-id=testredirect'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + # Should succeed and follow redirect + if result.returncode == 0: + output_title_file = tmpdir / 'title' / 'title.txt' + if output_title_file.exists(): + title_text = output_title_file.read_text().strip() + assert 'example' in title_text.lower() + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/archivebox/plugins/ublock/on_Snapshot__03_ublock.js b/archivebox/plugins/ublock/on_Snapshot__03_ublock.js new file mode 100755 index 00000000..190a24e6 --- /dev/null +++ b/archivebox/plugins/ublock/on_Snapshot__03_ublock.js @@ -0,0 +1,116 @@ +#!/usr/bin/env node +/** + * uBlock Origin Extension Plugin + * + * Installs and configures the uBlock Origin Chrome extension for ad blocking + * and privacy protection during page archiving. + * + * Extension: https://chromewebstore.google.com/detail/cjpalhdlnbpafiamejdnhcphjbkeiagm + * + * Priority: 03 (early) - Must install before Chrome session starts + * Hook: on_Snapshot + * + * This extension automatically: + * - Blocks ads, trackers, and malware domains + * - Reduces page load time and bandwidth usage + * - Improves privacy during archiving + * - Removes clutter from archived pages + * - Uses efficient blocking with filter lists + */ + +const path = require('path'); +const fs = require('fs'); + +// Import extension utilities +const extensionUtils = require('../chrome_extensions/chrome_extension_utils.js'); + +// Extension metadata +const EXTENSION = { + webstore_id: 'cjpalhdlnbpafiamejdnhcphjbkeiagm', + name: 'ublock', +}; + +// Get extensions directory from environment or use default +const EXTENSIONS_DIR = process.env.CHROME_EXTENSIONS_DIR || + path.join(process.env.DATA_DIR || './data', 'personas', process.env.ACTIVE_PERSONA || 'Default', 'chrome_extensions'); + +/** + * Install the uBlock Origin extension + */ +async function installUblockExtension() { + console.log('[*] Installing uBlock Origin extension...'); + + // Install the extension + const extension = await extensionUtils.loadOrInstallExtension(EXTENSION, EXTENSIONS_DIR); + + if (!extension) { + console.error('[❌] Failed to install uBlock Origin extension'); + return null; + } + + console.log('[+] uBlock Origin extension installed'); + console.log('[+] Ads and trackers will be blocked during archiving'); + + return extension; +} + +/** + * Note: uBlock Origin works automatically with default filter lists. + * No configuration needed - blocks ads, trackers, and malware domains out of the box. + */ + +/** + * Main entry point - install extension before archiving + */ +async function main() { + // Check if extension is already cached + const cacheFile = path.join(EXTENSIONS_DIR, 'ublock.extension.json'); + + if (fs.existsSync(cacheFile)) { + try { + const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); + const manifestPath = path.join(cached.unpacked_path, 'manifest.json'); + + if (fs.existsSync(manifestPath)) { + console.log('[*] uBlock Origin extension already installed (using cache)'); + return cached; + } + } catch (e) { + // Cache file corrupted, re-install + console.warn('[⚠️] Extension cache corrupted, re-installing...'); + } + } + + // Install extension + const extension = await installUblockExtension(); + + // Export extension metadata for chrome_session to load + if (extension) { + // Write extension info to a cache file that chrome_session can read + await fs.promises.mkdir(EXTENSIONS_DIR, { recursive: true }); + await fs.promises.writeFile( + cacheFile, + JSON.stringify(extension, null, 2) + ); + console.log(`[+] Extension metadata written to ${cacheFile}`); + } + + return extension; +} + +// Export functions for use by other plugins +module.exports = { + EXTENSION, + installUblockExtension, +}; + +// Run if executed directly +if (require.main === module) { + main().then(() => { + console.log('[✓] uBlock Origin extension setup complete'); + process.exit(0); + }).catch(err => { + console.error('[❌] uBlock Origin extension setup failed:', err); + process.exit(1); + }); +} diff --git a/archivebox/plugins/ublock/tests/test_ublock.js b/archivebox/plugins/ublock/tests/test_ublock.js new file mode 100644 index 00000000..80c6b604 --- /dev/null +++ b/archivebox/plugins/ublock/tests/test_ublock.js @@ -0,0 +1,321 @@ +/** + * Unit tests for ublock plugin + * + * Run with: node --test tests/test_ublock.js + */ + +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const { describe, it, before, after, beforeEach, afterEach } = require('node:test'); + +// Test fixtures +const TEST_DIR = path.join(__dirname, '.test_fixtures'); +const TEST_EXTENSIONS_DIR = path.join(TEST_DIR, 'chrome_extensions'); + +describe('ublock plugin', () => { + before(() => { + if (!fs.existsSync(TEST_DIR)) { + fs.mkdirSync(TEST_DIR, { recursive: true }); + } + }); + + after(() => { + if (fs.existsSync(TEST_DIR)) { + fs.rmSync(TEST_DIR, { recursive: true, force: true }); + } + }); + + describe('EXTENSION metadata', () => { + it('should have correct webstore_id for uBlock Origin', () => { + const { EXTENSION } = require('../on_Snapshot__03_ublock.js'); + + assert.strictEqual(EXTENSION.webstore_id, 'cjpalhdlnbpafiamejdnhcphjbkeiagm'); + }); + + it('should have correct name', () => { + const { EXTENSION } = require('../on_Snapshot__03_ublock.js'); + + assert.strictEqual(EXTENSION.name, 'ublock'); + }); + }); + + describe('installUblockExtension', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should use cached extension if available', async () => { + const { installUblockExtension } = require('../on_Snapshot__03_ublock.js'); + + // Create fake cache + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'ublock.extension.json'); + const fakeExtensionDir = path.join(TEST_EXTENSIONS_DIR, 'fake_ublock'); + + fs.mkdirSync(fakeExtensionDir, { recursive: true }); + fs.writeFileSync( + path.join(fakeExtensionDir, 'manifest.json'), + JSON.stringify({ version: '1.67.0' }) + ); + + const fakeCache = { + webstore_id: 'cjpalhdlnbpafiamejdnhcphjbkeiagm', + name: 'ublock', + unpacked_path: fakeExtensionDir, + version: '1.67.0' + }; + + fs.writeFileSync(cacheFile, JSON.stringify(fakeCache)); + + const result = await installUblockExtension(); + + assert.notStrictEqual(result, null); + assert.strictEqual(result.webstore_id, 'cjpalhdlnbpafiamejdnhcphjbkeiagm'); + }); + + it('should not require any configuration', async () => { + // uBlock Origin works out of the box with default filter lists + const { EXTENSION } = require('../on_Snapshot__03_ublock.js'); + + assert.ok(EXTENSION); + // No config fields should be required + }); + + it('should have large download size (filter lists)', () => { + // uBlock Origin is typically larger than other extensions + // due to included filter lists (usually 3-5 MB) + + const typicalSize = 4 * 1024 * 1024; // ~4 MB + const minExpectedSize = 2 * 1024 * 1024; // Minimum 2 MB + + // Just verify we understand the expected size + assert.ok(typicalSize > minExpectedSize); + }); + }); + + describe('cache file creation', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should create cache file with correct structure', async () => { + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'ublock.extension.json'); + + const mockExtension = { + webstore_id: 'cjpalhdlnbpafiamejdnhcphjbkeiagm', + name: 'ublock', + version: '1.68.0', + unpacked_path: path.join(TEST_EXTENSIONS_DIR, 'test_ublock'), + crx_path: path.join(TEST_EXTENSIONS_DIR, 'test_ublock.crx') + }; + + await fs.promises.writeFile(cacheFile, JSON.stringify(mockExtension, null, 2)); + + assert.ok(fs.existsSync(cacheFile)); + + const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); + assert.strictEqual(cache.name, 'ublock'); + assert.strictEqual(cache.webstore_id, 'cjpalhdlnbpafiamejdnhcphjbkeiagm'); + }); + }); + + describe('extension functionality', () => { + it('should work automatically with default filter lists', () => { + const features = { + automaticBlocking: true, + requiresConfiguration: false, + requiresApiKey: false, + defaultFilterLists: true, + blocksAds: true, + blocksTrackers: true, + blocksMalware: true + }; + + assert.strictEqual(features.automaticBlocking, true); + assert.strictEqual(features.requiresConfiguration, false); + assert.strictEqual(features.requiresApiKey, false); + assert.strictEqual(features.defaultFilterLists, true); + }); + + it('should not require runtime configuration', () => { + // uBlock Origin works purely via filter lists and content scripts + // No API keys or runtime configuration needed + + const requiresRuntimeConfig = false; + const requiresApiKey = false; + + assert.strictEqual(requiresRuntimeConfig, false); + assert.strictEqual(requiresApiKey, false); + }); + + it('should support standard filter list formats', () => { + const supportedFormats = [ + 'EasyList', + 'EasyPrivacy', + 'Malware Domains', + 'Peter Lowe\'s List', + 'uBlock Origin filters' + ]; + + assert.ok(supportedFormats.length > 0); + // Should support multiple filter list formats + }); + }); + + describe('priority and execution order', () => { + it('should have priority 03 (early)', () => { + const filename = 'on_Snapshot__03_ublock.js'; + + const match = filename.match(/on_Snapshot__(\d+)_/); + assert.ok(match); + + const priority = parseInt(match[1]); + assert.strictEqual(priority, 3); + }); + + it('should run before chrome_session (priority 20)', () => { + const extensionPriority = 3; + const chromeSessionPriority = 20; + + assert.ok(extensionPriority < chromeSessionPriority); + }); + + it('should run after cookie dismissal extension', () => { + const ublockPriority = 3; + const cookiesPriority = 2; + + assert.ok(ublockPriority > cookiesPriority); + }); + }); + + describe('performance considerations', () => { + it('should benefit from caching due to large size', () => { + // uBlock Origin's large size makes caching especially important + + const averageDownloadTime = 10; // seconds + const averageCacheCheckTime = 0.01; // seconds + + const performanceGain = averageDownloadTime / averageCacheCheckTime; + + // Should be at least 100x faster with cache + assert.ok(performanceGain > 100); + }); + + it('should not impact page load time significantly', () => { + // While extension is large, it uses efficient blocking + + const efficientBlocking = true; + const minimalOverhead = true; + + assert.strictEqual(efficientBlocking, true); + assert.strictEqual(minimalOverhead, true); + }); + }); + + describe('error handling', () => { + beforeEach(() => { + process.env.CHROME_EXTENSIONS_DIR = TEST_EXTENSIONS_DIR; + + if (!fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.mkdirSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(TEST_EXTENSIONS_DIR)) { + fs.rmSync(TEST_EXTENSIONS_DIR, { recursive: true }); + } + + delete process.env.CHROME_EXTENSIONS_DIR; + }); + + it('should handle corrupted cache gracefully', async () => { + const cacheFile = path.join(TEST_EXTENSIONS_DIR, 'ublock.extension.json'); + + // Create corrupted cache + fs.writeFileSync(cacheFile, 'invalid json content'); + + const { installUblockExtension } = require('../on_Snapshot__03_ublock.js'); + + // Mock loadOrInstallExtension to avoid actual download + const extensionUtils = require('../../chrome_extensions/chrome_extension_utils.js'); + const originalFunc = extensionUtils.loadOrInstallExtension; + + extensionUtils.loadOrInstallExtension = async () => ({ + webstore_id: 'cjpalhdlnbpafiamejdnhcphjbkeiagm', + name: 'ublock', + version: '1.68.0' + }); + + const result = await installUblockExtension(); + + extensionUtils.loadOrInstallExtension = originalFunc; + + assert.notStrictEqual(result, null); + }); + + it('should handle download timeout gracefully', () => { + // For large extension like uBlock, timeout handling is important + + const timeoutSeconds = 120; // 2 minutes + const minTimeout = 30; // Should allow at least 30 seconds + + assert.ok(timeoutSeconds > minTimeout); + }); + }); + + describe('filter list validation', () => { + it('should have valid filter list format', () => { + // Example filter list entry + const sampleFilters = [ + '||ads.example.com^', + '||tracker.example.com^$third-party', + '##.advertisement' + ]; + + // All filters should follow standard format + sampleFilters.forEach(filter => { + assert.ok(typeof filter === 'string'); + assert.ok(filter.length > 0); + }); + }); + + it('should support cosmetic filters', () => { + const cosmeticFilter = '##.banner-ad'; + + // Should start with ## for cosmetic filters + assert.ok(cosmeticFilter.startsWith('##')); + }); + + it('should support network filters', () => { + const networkFilter = '||ads.example.com^'; + + // Network filters typically start with || or contain ^ + assert.ok(networkFilter.includes('||') || networkFilter.includes('^')); + }); + }); +}); diff --git a/archivebox/plugins/ublock/tests/test_ublock.py b/archivebox/plugins/ublock/tests/test_ublock.py new file mode 100644 index 00000000..ad0360cc --- /dev/null +++ b/archivebox/plugins/ublock/tests/test_ublock.py @@ -0,0 +1,148 @@ +""" +Unit tests for ublock plugin + +Tests invoke the plugin hook as an external process and verify outputs/side effects. +""" + +import json +import os +import subprocess +import tempfile +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +INSTALL_SCRIPT = PLUGIN_DIR / "on_Snapshot__03_ublock.js" + + +def test_install_script_exists(): + """Verify install script exists""" + assert INSTALL_SCRIPT.exists(), f"Install script not found: {INSTALL_SCRIPT}" + + +def test_extension_metadata(): + """Test that uBlock Origin extension has correct metadata""" + with tempfile.TemporaryDirectory() as tmpdir: + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(Path(tmpdir) / "chrome_extensions") + + result = subprocess.run( + ["node", "-e", f"const ext = require('{INSTALL_SCRIPT}'); console.log(JSON.stringify(ext.EXTENSION))"], + capture_output=True, + text=True, + env=env + ) + + assert result.returncode == 0, f"Failed to load extension metadata: {result.stderr}" + + metadata = json.loads(result.stdout) + assert metadata["webstore_id"] == "cjpalhdlnbpafiamejdnhcphjbkeiagm" + assert metadata["name"] == "ublock" + + +def test_install_creates_cache(): + """Test that install creates extension cache""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=120 # uBlock is large, may take longer to download + ) + + # Check output mentions installation + assert "uBlock" in result.stdout or "ublock" in result.stdout + + # Check cache file was created + cache_file = ext_dir / "ublock.extension.json" + assert cache_file.exists(), "Cache file should be created" + + # Verify cache content + cache_data = json.loads(cache_file.read_text()) + assert cache_data["webstore_id"] == "cjpalhdlnbpafiamejdnhcphjbkeiagm" + assert cache_data["name"] == "ublock" + + +def test_install_uses_existing_cache(): + """Test that install uses existing cache when available""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + # Create fake cache + fake_extension_dir = ext_dir / "cjpalhdlnbpafiamejdnhcphjbkeiagm__ublock" + fake_extension_dir.mkdir(parents=True) + + manifest = {"version": "1.68.0", "name": "uBlock Origin"} + (fake_extension_dir / "manifest.json").write_text(json.dumps(manifest)) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Should use cache or install successfully + assert result.returncode == 0 + + +def test_no_configuration_required(): + """Test that uBlock Origin works without configuration""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + # No API keys needed - works with default filter lists + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=120 + ) + + # Should not require any API keys + combined_output = result.stdout + result.stderr + assert "API" not in combined_output or result.returncode == 0 + + +def test_large_extension_size(): + """Test that uBlock Origin is downloaded successfully despite large size""" + with tempfile.TemporaryDirectory() as tmpdir: + ext_dir = Path(tmpdir) / "chrome_extensions" + ext_dir.mkdir(parents=True) + + env = os.environ.copy() + env["CHROME_EXTENSIONS_DIR"] = str(ext_dir) + + result = subprocess.run( + ["node", str(INSTALL_SCRIPT)], + capture_output=True, + text=True, + env=env, + timeout=120 + ) + + # If extension was downloaded, verify it's substantial size + crx_file = ext_dir / "cjpalhdlnbpafiamejdnhcphjbkeiagm__ublock.crx" + if crx_file.exists(): + # uBlock Origin with filter lists is typically 2-5 MB + size_bytes = crx_file.stat().st_size + assert size_bytes > 1_000_000, f"uBlock Origin should be > 1MB, got {size_bytes} bytes" diff --git a/archivebox/plugins/wget/config.json b/archivebox/plugins/wget/config.json new file mode 100644 index 00000000..69d1e0c1 --- /dev/null +++ b/archivebox/plugins/wget/config.json @@ -0,0 +1,80 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "additionalProperties": false, + "properties": { + "SAVE_WGET": { + "type": "boolean", + "default": true, + "description": "Enable wget archiving" + }, + "SAVE_WARC": { + "type": "boolean", + "default": true, + "description": "Save WARC archive file" + }, + "SAVE_WGET_REQUISITES": { + "type": "boolean", + "default": true, + "description": "Download page requisites (CSS, JS, images)" + }, + "WGET_BINARY": { + "type": "string", + "default": "wget", + "description": "Path to wget binary" + }, + "WGET_TIMEOUT": { + "type": "integer", + "default": 60, + "minimum": 5, + "x-fallback": "TIMEOUT", + "description": "Timeout for wget in seconds" + }, + "WGET_USER_AGENT": { + "type": "string", + "default": "", + "x-fallback": "USER_AGENT", + "description": "User agent string for wget" + }, + "WGET_CHECK_SSL_VALIDITY": { + "type": "boolean", + "default": true, + "x-fallback": "CHECK_SSL_VALIDITY", + "x-aliases": ["CHECK_SSL_VALIDITY"], + "description": "Whether to verify SSL certificates" + }, + "WGET_COOKIES_FILE": { + "type": "string", + "default": "", + "x-fallback": "COOKIES_FILE", + "description": "Path to cookies file" + }, + "WGET_RESTRICT_FILE_NAMES": { + "type": "string", + "default": "windows", + "enum": ["windows", "unix", "ascii", "nocontrol", "lowercase", "uppercase"], + "x-fallback": "RESTRICT_FILE_NAMES", + "description": "Filename restriction mode" + }, + "WGET_ARGS": { + "type": "array", + "items": {"type": "string"}, + "default": [ + "--no-verbose", + "--adjust-extension", + "--convert-links", + "--force-directories", + "--backup-converted", + "--span-hosts", + "--no-parent", + "-e", "robots=off" + ], + "description": "Default wget arguments" + }, + "WGET_EXTRA_ARGS": { + "type": "string", + "default": "", + "description": "Extra arguments for wget (space-separated)" + } + } +} diff --git a/archivebox/plugins/wget/on_Crawl__00_validate_wget.py b/archivebox/plugins/wget/on_Crawl__00_validate_wget.py new file mode 100644 index 00000000..f66f69e6 --- /dev/null +++ b/archivebox/plugins/wget/on_Crawl__00_validate_wget.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 +""" +Validation hook for wget binary. + +Runs at crawl start to verify wget is available. +Outputs JSONL for InstalledBinary and Machine config updates. +""" + +import os +import sys +import json +import shutil +import hashlib +import subprocess +from pathlib import Path + + +def get_binary_version(abspath: str) -> str | None: + """Get version string from binary.""" + try: + result = subprocess.run( + [abspath, '--version'], + capture_output=True, + text=True, + timeout=5, + ) + if result.returncode == 0 and result.stdout: + # wget version string: "GNU Wget 1.24.5 built on ..." + first_line = result.stdout.strip().split('\n')[0] + # Extract version number + parts = first_line.split() + for i, part in enumerate(parts): + if part.lower() == 'wget' and i + 1 < len(parts): + return parts[i + 1] + return first_line[:32] + except Exception: + pass + return None + + +def get_binary_hash(abspath: str) -> str | None: + """Get SHA256 hash of binary.""" + try: + with open(abspath, 'rb') as f: + return hashlib.sha256(f.read()).hexdigest() + except Exception: + return None + + +def find_wget() -> dict | None: + """Find wget binary using abx-pkg or fallback to shutil.which.""" + # Try abx-pkg first + try: + from abx_pkg import Binary, EnvProvider + + class WgetBinary(Binary): + name: str = 'wget' + binproviders_supported = [EnvProvider()] + + binary = WgetBinary() + loaded = binary.load() + if loaded and loaded.abspath: + return { + 'name': 'wget', + 'abspath': str(loaded.abspath), + 'version': str(loaded.version) if loaded.version else None, + 'sha256': loaded.sha256 if hasattr(loaded, 'sha256') else None, + 'binprovider': loaded.binprovider.name if loaded.binprovider else 'env', + } + except ImportError: + pass + except Exception: + pass + + # Fallback to shutil.which + abspath = shutil.which('wget') or os.environ.get('WGET_BINARY', '') + if abspath and Path(abspath).is_file(): + return { + 'name': 'wget', + 'abspath': abspath, + 'version': get_binary_version(abspath), + 'sha256': get_binary_hash(abspath), + 'binprovider': 'env', + } + + return None + + +def main(): + """Validate wget binary and output JSONL.""" + + result = find_wget() + + if result and result.get('abspath'): + # Output InstalledBinary + print(json.dumps({ + 'type': 'InstalledBinary', + 'name': result['name'], + 'abspath': result['abspath'], + 'version': result['version'], + 'sha256': result['sha256'], + 'binprovider': result['binprovider'], + })) + + # Output Machine config update + print(json.dumps({ + 'type': 'Machine', + '_method': 'update', + 'key': 'config/WGET_BINARY', + 'value': result['abspath'], + })) + + if result['version']: + print(json.dumps({ + 'type': 'Machine', + '_method': 'update', + 'key': 'config/WGET_VERSION', + 'value': result['version'], + })) + + sys.exit(0) + else: + # Output Dependency request + print(json.dumps({ + 'type': 'Dependency', + 'bin_name': 'wget', + 'bin_providers': 'apt,brew,env', + })) + + # Exit non-zero to indicate binary not found + print(f"wget binary not found", file=sys.stderr) + sys.exit(1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/wget/on_Crawl__00_validate_wget_config.py b/archivebox/plugins/wget/on_Crawl__00_validate_wget_config.py new file mode 100644 index 00000000..e61ed590 --- /dev/null +++ b/archivebox/plugins/wget/on_Crawl__00_validate_wget_config.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +""" +Validate and compute derived wget config values. + +This hook runs early in the Crawl lifecycle to: +1. Validate config values with warnings (not hard errors) +2. Compute derived values (USE_WGET from SAVE_WGET/SAVE_WARC) +3. Check binary availability and version + +Output: + - COMPUTED:KEY=VALUE lines that hooks.py parses and adds to env + - InstalledBinary JSONL records to stdout when binaries are found +""" + +import json +import os +import shutil +import subprocess +import sys + +from abx_pkg import Binary, EnvProvider + + +# Read config from environment (already validated by JSONSchema) +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +def output_installed_binary(binary: Binary, name: str): + """Output InstalledBinary JSONL record to stdout.""" + machine_id = os.environ.get('MACHINE_ID', '') + + record = { + 'type': 'InstalledBinary', + 'name': name, + 'abspath': str(binary.abspath), + 'version': str(binary.version) if binary.version else '', + 'sha256': binary.sha256 or '', + 'binprovider': 'env', + 'machine_id': machine_id, + } + print(json.dumps(record)) + + +def main(): + warnings = [] + errors = [] + computed = {} + + # Get config values + save_wget = get_env_bool('SAVE_WGET', True) + save_warc = get_env_bool('SAVE_WARC', True) + wget_timeout = get_env_int('WGET_TIMEOUT') or get_env_int('TIMEOUT', 60) + wget_binary = get_env('WGET_BINARY', 'wget') + + # Compute derived values + use_wget = save_wget or save_warc + computed['USE_WGET'] = str(use_wget).lower() + + # Validate timeout with warning (not error) + if use_wget and wget_timeout < 20: + warnings.append( + f"WGET_TIMEOUT={wget_timeout} is very low. " + "wget may fail to archive sites if set to less than ~20 seconds. " + "Consider setting WGET_TIMEOUT=60 or higher." + ) + + # Check binary availability using abx-pkg + provider = EnvProvider() + try: + binary = Binary(name=wget_binary, binproviders=[provider]).load() + binary_path = str(binary.abspath) if binary.abspath else '' + except Exception: + binary = None + binary_path = '' + + if not binary_path: + if use_wget: + errors.append(f"WGET_BINARY={wget_binary} not found. Install wget or set SAVE_WGET=false.") + computed['WGET_BINARY'] = '' + else: + computed['WGET_BINARY'] = binary_path + wget_version = str(binary.version) if binary.version else 'unknown' + computed['WGET_VERSION'] = wget_version + + # Output InstalledBinary JSONL record + output_installed_binary(binary, name='wget') + + # Check for compression support + if computed.get('WGET_BINARY'): + try: + result = subprocess.run( + [computed['WGET_BINARY'], '--compression=auto', '--help'], + capture_output=True, timeout=5 + ) + computed['WGET_AUTO_COMPRESSION'] = 'true' if result.returncode == 0 else 'false' + except Exception: + computed['WGET_AUTO_COMPRESSION'] = 'false' + + # Output results + # Format: KEY=VALUE lines that hooks.py will parse and add to env + for key, value in computed.items(): + print(f"COMPUTED:{key}={value}") + + for warning in warnings: + print(f"WARNING:{warning}", file=sys.stderr) + + for error in errors: + print(f"ERROR:{error}", file=sys.stderr) + + # Exit with error if any hard errors + sys.exit(1 if errors else 0) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/wget/on_Snapshot__50_wget.py b/archivebox/plugins/wget/on_Snapshot__50_wget.py new file mode 100644 index 00000000..4b409d8c --- /dev/null +++ b/archivebox/plugins/wget/on_Snapshot__50_wget.py @@ -0,0 +1,325 @@ +#!/usr/bin/env python3 +""" +Archive a URL using wget. + +Usage: on_Snapshot__wget.py --url=<url> --snapshot-id=<uuid> +Output: Downloads files to $PWD + +Environment variables: + WGET_BINARY: Path to wget binary (optional, falls back to PATH) + WGET_TIMEOUT: Timeout in seconds (default: 60) + WGET_USER_AGENT: User agent string + WGET_CHECK_SSL_VALIDITY: Whether to check SSL certificates (default: True) + WGET_COOKIES_FILE: Path to cookies file (optional) + WGET_RESTRICT_FILE_NAMES: Filename restriction mode (default: windows) + WGET_EXTRA_ARGS: Extra arguments for wget (space-separated) + + # Wget feature toggles + SAVE_WGET: Enable wget archiving (default: True) + SAVE_WARC: Save WARC file (default: True) + SAVE_WGET_REQUISITES: Download page requisites (default: True) + + # Fallback to ARCHIVING_CONFIG values if WGET_* not set: + TIMEOUT: Fallback timeout + USER_AGENT: Fallback user agent + CHECK_SSL_VALIDITY: Fallback SSL check + COOKIES_FILE: Fallback cookies file + RESTRICT_FILE_NAMES: Fallback filename restriction +""" + +import json +import os +import re +import shutil +import subprocess +import sys +from datetime import datetime, timezone +from pathlib import Path + +import rich_click as click + + +# Extractor metadata +EXTRACTOR_NAME = 'wget' +BIN_NAME = 'wget' +BIN_PROVIDERS = 'apt,brew,env' +OUTPUT_DIR = 'wget' + + +def get_env(name: str, default: str = '') -> str: + return os.environ.get(name, default).strip() + + +def get_env_bool(name: str, default: bool = False) -> bool: + val = get_env(name, '').lower() + if val in ('true', '1', 'yes', 'on'): + return True + if val in ('false', '0', 'no', 'off'): + return False + return default + + +def get_env_int(name: str, default: int = 0) -> int: + try: + return int(get_env(name, str(default))) + except ValueError: + return default + + +STATICFILE_DIR = 'staticfile' + +def has_staticfile_output() -> bool: + """Check if staticfile extractor already downloaded this URL.""" + staticfile_dir = Path(STATICFILE_DIR) + return staticfile_dir.exists() and any(staticfile_dir.iterdir()) + + +def find_wget() -> str | None: + """Find wget binary.""" + wget = get_env('WGET_BINARY') + if wget and os.path.isfile(wget): + return wget + return shutil.which('wget') + + +def get_version(binary: str) -> str: + """Get wget version.""" + try: + result = subprocess.run([binary, '--version'], capture_output=True, text=True, timeout=10) + return result.stdout.split('\n')[0].strip()[:64] + except Exception: + return '' + + +def check_wget_compression(binary: str) -> bool: + """Check if wget supports --compression=auto.""" + try: + result = subprocess.run( + [binary, '--compression=auto', '--help'], + capture_output=True, + timeout=5 + ) + return result.returncode == 0 + except Exception: + return False + + +# Default wget args (from old WGET_CONFIG) +WGET_DEFAULT_ARGS = [ + '--no-verbose', + '--adjust-extension', + '--convert-links', + '--force-directories', + '--backup-converted', + '--span-hosts', + '--no-parent', + '-e', 'robots=off', +] + + +def save_wget(url: str, binary: str) -> tuple[bool, str | None, str]: + """ + Archive URL using wget. + + Returns: (success, output_path, error_message) + """ + # Get config from env (with WGET_ prefix or fallback to ARCHIVING_CONFIG style) + timeout = get_env_int('WGET_TIMEOUT') or get_env_int('TIMEOUT', 60) + user_agent = get_env('WGET_USER_AGENT') or get_env('USER_AGENT', 'Mozilla/5.0 (compatible; ArchiveBox/1.0)') + check_ssl = get_env_bool('WGET_CHECK_SSL_VALIDITY', get_env_bool('CHECK_SSL_VALIDITY', True)) + cookies_file = get_env('WGET_COOKIES_FILE') or get_env('COOKIES_FILE', '') + restrict_names = get_env('WGET_RESTRICT_FILE_NAMES') or get_env('RESTRICT_FILE_NAMES', 'windows') + extra_args = get_env('WGET_EXTRA_ARGS', '') + + # Feature toggles + save_warc = get_env_bool('SAVE_WARC', True) + save_requisites = get_env_bool('SAVE_WGET_REQUISITES', True) + + # Check for compression support + supports_compression = check_wget_compression(binary) + + # Build wget command (later options take precedence) + cmd = [ + binary, + *WGET_DEFAULT_ARGS, + f'--timeout={timeout}', + '--tries=2', + ] + + if user_agent: + cmd.append(f'--user-agent={user_agent}') + + if restrict_names: + cmd.append(f'--restrict-file-names={restrict_names}') + + if save_requisites: + cmd.append('--page-requisites') + + if save_warc: + warc_dir = Path('warc') + warc_dir.mkdir(exist_ok=True) + warc_path = warc_dir / str(int(datetime.now(timezone.utc).timestamp())) + cmd.append(f'--warc-file={warc_path}') + else: + cmd.append('--timestamping') + + if cookies_file and Path(cookies_file).is_file(): + cmd.extend(['--load-cookies', cookies_file]) + + if supports_compression: + cmd.append('--compression=auto') + + if not check_ssl: + cmd.extend(['--no-check-certificate', '--no-hsts']) + + if extra_args: + cmd.extend(extra_args.split()) + + cmd.append(url) + + # Run wget + try: + result = subprocess.run( + cmd, + capture_output=True, + timeout=timeout * 2, # Allow extra time for large downloads + ) + + # Find downloaded files + downloaded_files = [ + f for f in Path('.').rglob('*') + if f.is_file() and f.name != '.gitkeep' and not str(f).startswith('warc/') + ] + + if not downloaded_files: + stderr = result.stderr.decode('utf-8', errors='replace') + stdout = result.stdout.decode('utf-8', errors='replace') + combined = stderr + stdout + + if '403' in combined or 'Forbidden' in combined: + return False, None, '403 Forbidden (try changing USER_AGENT)' + elif '404' in combined or 'Not Found' in combined: + return False, None, '404 Not Found' + elif '500' in combined: + return False, None, '500 Internal Server Error' + else: + return False, None, f'No files downloaded: {stderr[:200]}' + + # Find main HTML file + html_files = [ + f for f in downloaded_files + if re.search(r'\.[Ss]?[Hh][Tt][Mm][Ll]?$', str(f)) + ] + output_path = str(html_files[0]) if html_files else str(downloaded_files[0]) + + # Parse download stats from wget output + output_tail = result.stderr.decode('utf-8', errors='replace').strip().split('\n')[-3:] + files_count = len(downloaded_files) + + return True, output_path, '' + + except subprocess.TimeoutExpired: + return False, None, f'Timed out after {timeout * 2} seconds' + except Exception as e: + return False, None, f'{type(e).__name__}: {e}' + + +@click.command() +@click.option('--url', required=True, help='URL to archive') +@click.option('--snapshot-id', required=True, help='Snapshot UUID') +def main(url: str, snapshot_id: str): + """Archive a URL using wget.""" + + start_ts = datetime.now(timezone.utc) + version = '' + output = None + status = 'failed' + error = '' + binary = None + cmd_str = '' + + try: + # Check if wget is enabled + if not get_env_bool('SAVE_WGET', True): + print('Skipping wget (SAVE_WGET=False)') + status = 'skipped' + end_ts = datetime.now(timezone.utc) + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'STATUS={status}') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": status, "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) + + # Check if staticfile extractor already handled this (permanent skip) + if has_staticfile_output(): + print(f'Skipping wget - staticfile extractor already downloaded this') + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={datetime.now(timezone.utc).isoformat()}') + print(f'STATUS=skipped') + print(f'RESULT_JSON={json.dumps({"extractor": EXTRACTOR_NAME, "status": "skipped", "url": url, "snapshot_id": snapshot_id})}') + sys.exit(0) # Permanent skip - staticfile already handled + + # Find binary + binary = find_wget() + if not binary: + print(f'ERROR: {BIN_NAME} binary not found', file=sys.stderr) + print(f'DEPENDENCY_NEEDED={BIN_NAME}', file=sys.stderr) + print(f'BIN_PROVIDERS={BIN_PROVIDERS}', file=sys.stderr) + print(f'INSTALL_HINT=apt install wget OR brew install wget', file=sys.stderr) + sys.exit(1) + + version = get_version(binary) + cmd_str = f'{binary} ... {url}' + + # Run extraction + success, output, error = save_wget(url, binary) + status = 'succeeded' if success else 'failed' + + if success: + # Count downloaded files + files = list(Path('.').rglob('*')) + file_count = len([f for f in files if f.is_file()]) + print(f'wget completed: {file_count} files downloaded') + + except Exception as e: + error = f'{type(e).__name__}: {e}' + status = 'failed' + + # Print results + end_ts = datetime.now(timezone.utc) + duration = (end_ts - start_ts).total_seconds() + + print(f'START_TS={start_ts.isoformat()}') + print(f'END_TS={end_ts.isoformat()}') + print(f'DURATION={duration:.2f}') + if cmd_str: + print(f'CMD={cmd_str}') + if version: + print(f'VERSION={version}') + if output: + print(f'OUTPUT={output}') + print(f'STATUS={status}') + + if error: + print(f'ERROR={error}', file=sys.stderr) + + # Print JSON result + result_json = { + 'extractor': EXTRACTOR_NAME, + 'url': url, + 'snapshot_id': snapshot_id, + 'status': status, + 'start_ts': start_ts.isoformat(), + 'end_ts': end_ts.isoformat(), + 'duration': round(duration, 2), + 'cmd_version': version, + 'output': output, + 'error': error or None, + } + print(f'RESULT_JSON={json.dumps(result_json)}') + + sys.exit(0 if status == 'succeeded' else 1) + + +if __name__ == '__main__': + main() diff --git a/archivebox/plugins/wget/tests/test_wget.py b/archivebox/plugins/wget/tests/test_wget.py new file mode 100644 index 00000000..4ea35723 --- /dev/null +++ b/archivebox/plugins/wget/tests/test_wget.py @@ -0,0 +1,369 @@ +""" +Integration tests for wget plugin + +Tests verify: +1. Plugin reports missing dependency correctly +2. wget can be installed via brew/apt provider hooks +3. Config options work (SAVE_WGET, SAVE_WARC, etc.) +4. Extraction works against real example.com +5. Output files contain actual page content +6. Skip cases work (SAVE_WGET=False, staticfile present) +7. Failure cases handled (404, network errors) +""" + +import json +import os +import shutil +import subprocess +import sys +import tempfile +import uuid +from pathlib import Path + +import pytest + + +PLUGIN_DIR = Path(__file__).parent.parent +PLUGINS_ROOT = PLUGIN_DIR.parent +WGET_HOOK = next(PLUGIN_DIR.glob('on_Snapshot__*_wget.py')) +BREW_HOOK = PLUGINS_ROOT / 'brew' / 'on_Dependency__install_using_brew_provider.py' +APT_HOOK = PLUGINS_ROOT / 'apt' / 'on_Dependency__install_using_apt_provider.py' +TEST_URL = 'https://example.com' + + +def test_hook_script_exists(): + """Verify hook script exists.""" + assert WGET_HOOK.exists(), f"Hook script not found: {WGET_HOOK}" + + +def test_reports_missing_dependency_when_not_installed(): + """Test that script reports DEPENDENCY_NEEDED when wget is not found.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Run with empty PATH so binary won't be found + env = {'PATH': '/nonexistent', 'HOME': str(tmpdir)} + + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'test123'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env + ) + + # Should fail and report missing dependency + assert result.returncode != 0, "Should exit non-zero when dependency missing" + combined = result.stdout + result.stderr + assert 'DEPENDENCY_NEEDED' in combined, "Should output DEPENDENCY_NEEDED" + assert 'wget' in combined.lower(), "Should mention wget" + assert 'BIN_PROVIDERS' in combined, "Should report available providers (apt,brew,env)" + + +def test_can_install_wget_via_provider(): + """Test that wget can be installed via brew/apt provider hooks.""" + + # Determine which provider to use + if shutil.which('brew'): + provider_hook = BREW_HOOK + provider_name = 'brew' + elif shutil.which('apt-get'): + provider_hook = APT_HOOK + provider_name = 'apt' + else: + pytest.skip("Neither brew nor apt available on this system") + + assert provider_hook.exists(), f"Provider hook not found: {provider_hook}" + + # Test installation via provider hook + dependency_id = str(uuid.uuid4()) + + result = subprocess.run( + [ + sys.executable, + str(provider_hook), + '--dependency-id', dependency_id, + '--bin-name', 'wget', + '--bin-providers', 'apt,brew,env' + ], + capture_output=True, + text=True, + timeout=300 # Installation can take time + ) + + # Should succeed (wget installs successfully or is already installed) + assert result.returncode == 0, f"{provider_name} install failed: {result.stderr}" + + # Should output InstalledBinary JSONL record + assert 'InstalledBinary' in result.stdout or 'wget' in result.stderr, \ + f"Should output installation info: stdout={result.stdout}, stderr={result.stderr}" + + # Parse JSONL if present + if result.stdout.strip(): + for line in result.stdout.strip().split('\n'): + try: + record = json.loads(line) + if record.get('type') == 'InstalledBinary': + assert record['name'] == 'wget' + assert record['binprovider'] in ['brew', 'apt'] + assert record['abspath'], "Should have binary path" + assert Path(record['abspath']).exists(), f"Binary should exist at {record['abspath']}" + break + except json.JSONDecodeError: + continue + + # Verify wget is now available + result = subprocess.run(['which', 'wget'], capture_output=True, text=True) + assert result.returncode == 0, "wget should be available after installation" + + +def test_archives_example_com(): + """Test full workflow: ensure wget installed then archive example.com.""" + + # First ensure wget is installed via provider + if shutil.which('brew'): + provider_hook = BREW_HOOK + elif shutil.which('apt-get'): + provider_hook = APT_HOOK + else: + pytest.skip("Neither brew nor apt available") + + # Run installation (idempotent - will succeed if already installed) + install_result = subprocess.run( + [ + sys.executable, + str(provider_hook), + '--dependency-id', str(uuid.uuid4()), + '--bin-name', 'wget', + '--bin-providers', 'apt,brew,env' + ], + capture_output=True, + text=True, + timeout=300 + ) + + if install_result.returncode != 0: + pytest.skip(f"Could not install wget: {install_result.stderr}") + + # Now test archiving + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Run wget extraction + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'test789'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=120 + ) + + assert result.returncode == 0, f"Extraction failed: {result.stderr}" + + # Verify output in stdout + assert 'STATUS=succeeded' in result.stdout, "Should report success" + assert 'wget completed' in result.stdout, "Should report completion" + + # Verify files were downloaded + downloaded_files = list(tmpdir.rglob('*.html')) + list(tmpdir.rglob('*.htm')) + assert len(downloaded_files) > 0, "No HTML files downloaded" + + # Find main HTML file (should contain example.com) + main_html = None + for html_file in downloaded_files: + content = html_file.read_text(errors='ignore') + if 'example domain' in content.lower(): + main_html = html_file + break + + assert main_html is not None, "Could not find main HTML file with example.com content" + + # Verify HTML content contains REAL example.com text + html_content = main_html.read_text(errors='ignore') + assert len(html_content) > 200, f"HTML content too short: {len(html_content)} bytes" + assert 'example domain' in html_content.lower(), "Missing 'Example Domain' in HTML" + assert ('this domain' in html_content.lower() or + 'illustrative examples' in html_content.lower()), \ + "Missing example.com description text" + assert ('iana' in html_content.lower() or + 'more information' in html_content.lower()), \ + "Missing IANA reference" + + # Verify RESULT_JSON is present and valid + assert 'RESULT_JSON=' in result.stdout, "Should output RESULT_JSON" + + for line in result.stdout.split('\n'): + if line.startswith('RESULT_JSON='): + result_json = json.loads(line.replace('RESULT_JSON=', '')) + assert result_json['extractor'] == 'wget' + assert result_json['status'] == 'succeeded' + assert result_json['url'] == TEST_URL + assert result_json['snapshot_id'] == 'test789' + assert 'duration' in result_json + assert result_json['duration'] >= 0 + break + + +def test_config_save_wget_false_skips(): + """Test that SAVE_WGET=False causes skip.""" + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set SAVE_WGET=False + env = os.environ.copy() + env['SAVE_WGET'] = 'False' + + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'test999'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Should succeed but skip + assert result.returncode == 0, f"Should exit 0 when skipping: {result.stderr}" + assert 'STATUS=skipped' in result.stdout, "Should report skipped status" + assert 'SAVE_WGET=False' in result.stdout, "Should mention SAVE_WGET=False" + + +def test_config_save_warc(): + """Test that SAVE_WARC=True creates WARC files.""" + + # Ensure wget is available + if not shutil.which('wget'): + pytest.skip("wget not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set SAVE_WARC=True explicitly + env = os.environ.copy() + env['SAVE_WARC'] = 'True' + + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'testwarc'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=120 + ) + + if result.returncode == 0: + # Look for WARC files in warc/ subdirectory + warc_dir = tmpdir / 'warc' + if warc_dir.exists(): + warc_files = list(warc_dir.rglob('*')) + warc_files = [f for f in warc_files if f.is_file()] + assert len(warc_files) > 0, "WARC file not created when SAVE_WARC=True" + + +def test_staticfile_present_skips(): + """Test that wget skips when staticfile already downloaded.""" + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Create staticfile directory with content to simulate staticfile extractor ran + staticfile_dir = tmpdir / 'staticfile' + staticfile_dir.mkdir() + (staticfile_dir / 'index.html').write_text('<html>test</html>') + + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'teststatic'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=30 + ) + + # Should skip + assert result.returncode == 0, "Should exit 0 when skipping" + assert 'STATUS=skipped' in result.stdout, "Should report skipped status" + assert 'staticfile' in result.stdout.lower(), "Should mention staticfile" + + +def test_handles_404_gracefully(): + """Test that wget fails gracefully on 404.""" + + if not shutil.which('wget'): + pytest.skip("wget not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Try to download non-existent page + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', 'https://example.com/nonexistent-page-404', '--snapshot-id', 'test404'], + cwd=tmpdir, + capture_output=True, + text=True, + timeout=60 + ) + + # Should fail + assert result.returncode != 0, "Should fail on 404" + combined = result.stdout + result.stderr + assert '404' in combined or 'Not Found' in combined or 'No files downloaded' in combined, \ + "Should report 404 or no files downloaded" + + +def test_config_timeout_honored(): + """Test that WGET_TIMEOUT config is respected.""" + + if not shutil.which('wget'): + pytest.skip("wget not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set very short timeout + env = os.environ.copy() + env['WGET_TIMEOUT'] = '5' + + # This should still succeed for example.com (it's fast) + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'testtimeout'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=30 + ) + + # Verify it completed (success or fail, but didn't hang) + assert result.returncode in (0, 1), "Should complete (success or fail)" + + +def test_config_user_agent(): + """Test that WGET_USER_AGENT config is used.""" + + if not shutil.which('wget'): + pytest.skip("wget not installed") + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Set custom user agent + env = os.environ.copy() + env['WGET_USER_AGENT'] = 'TestBot/1.0' + + result = subprocess.run( + [sys.executable, str(WGET_HOOK), '--url', TEST_URL, '--snapshot-id', 'testua'], + cwd=tmpdir, + capture_output=True, + text=True, + env=env, + timeout=120 + ) + + # Should succeed (example.com doesn't block) + if result.returncode == 0: + assert 'STATUS=succeeded' in result.stdout + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/archivebox/search/__init__.py b/archivebox/search/__init__.py index ea059db1..7cd581e6 100644 --- a/archivebox/search/__init__.py +++ b/archivebox/search/__init__.py @@ -1,143 +1,120 @@ +""" +Search module for ArchiveBox. + +Search indexing is handled by search backend hooks in plugins: + archivebox/plugins/search_backend_*/on_Snapshot__*_index_*.py + +This module provides the query interface that dynamically discovers +search backend plugins using the hooks system. + +Search backends must provide a search.py module with: + - search(query: str) -> List[str] (returns snapshot IDs) + - flush(snapshot_ids: Iterable[str]) -> None +""" + __package__ = 'archivebox.search' -from pathlib import Path -from typing import List, Union +from typing import TYPE_CHECKING, Any, Optional from django.db.models import QuerySet -from django.conf import settings -import abx -import archivebox -from archivebox.index.schema import Link from archivebox.misc.util import enforce_types from archivebox.misc.logging import stderr from archivebox.config.common import SEARCH_BACKEND_CONFIG - -def log_index_started(url): - print('[green][*] Indexing url: {} in the search index[/]'.format(url)) - print( ) - -def get_file_result_content(res, extra_path, use_pwd=False): - if use_pwd: - fpath = f'{res.pwd}/{res.output}' - else: - fpath = f'{res.output}' - - if extra_path: - fpath = f'{fpath}/{extra_path}' - - with open(fpath, 'r', encoding='utf-8') as file: - data = file.read() - if data: - return [data] - return [] - - -# TODO: This should be abstracted by a plugin interface for extractors -@enforce_types -def get_indexable_content(results: QuerySet): - if not results: - return [] - # Only use the first method available - res, method = results.first(), results.first().extractor - if method not in ('readability', 'singlefile', 'dom', 'wget'): - return [] - # This should come from a plugin interface - - # TODO: banish this duplication and get these from the extractor file - if method == 'readability': - return get_file_result_content(res, 'content.txt', use_pwd=True) - elif method == 'singlefile': - return get_file_result_content(res, '', use_pwd=True) - elif method == 'dom': - return get_file_result_content(res, '', use_pwd=True) - elif method == 'wget': - return get_file_result_content(res, '', use_pwd=True) - - -def import_backend(): - for backend in abx.as_dict(archivebox.pm.hook.get_SEARCHBACKENDS()).values(): - if backend.name == SEARCH_BACKEND_CONFIG.SEARCH_BACKEND_ENGINE: - return backend - raise Exception(f'Could not load {SEARCH_BACKEND_CONFIG.SEARCH_BACKEND_ENGINE} as search backend') - -@enforce_types -def write_search_index(link: Link, texts: Union[List[str], None]=None, out_dir: Path=settings.DATA_DIR, skip_text_index: bool=False) -> None: - if not SEARCH_BACKEND_CONFIG.USE_INDEXING_BACKEND: - return - - if not skip_text_index and texts: - from core.models import Snapshot - - snap = Snapshot.objects.filter(url=link.url).first() - backend = import_backend() - if snap: - try: - backend.index(snapshot_id=str(snap.pk), texts=texts) - except Exception as err: - stderr() - stderr( - f'[X] The search backend threw an exception={err}:', - color='red', - ) - -@enforce_types -def query_search_index(query: str, out_dir: Path=settings.DATA_DIR) -> QuerySet: +if TYPE_CHECKING: from core.models import Snapshot - if SEARCH_BACKEND_CONFIG.USE_SEARCHING_BACKEND: - backend = import_backend() - try: - snapshot_pks = backend.search(query) - except Exception as err: - stderr() - stderr( - f'[X] The search backend threw an exception={err}:', - color='red', - ) - raise - else: - # TODO preserve ordering from backend - qsearch = Snapshot.objects.filter(pk__in=snapshot_pks) - return qsearch - - return Snapshot.objects.none() + +# Cache discovered backends to avoid repeated filesystem scans +_search_backends_cache: Optional[dict] = None + + +def get_available_backends() -> dict: + """ + Discover all available search backend plugins. + + Uses the hooks system to find plugins with search.py modules. + Results are cached after first call. + """ + global _search_backends_cache + + if _search_backends_cache is None: + from archivebox.hooks import get_search_backends + _search_backends_cache = get_search_backends() + + return _search_backends_cache + + +def get_backend() -> Any: + """ + Get the configured search backend module. + + Discovers available backends via the hooks system and returns + the one matching SEARCH_BACKEND_ENGINE configuration. + + Falls back to 'ripgrep' if configured backend is not found. + """ + backend_name = SEARCH_BACKEND_CONFIG.SEARCH_BACKEND_ENGINE + backends = get_available_backends() + + if backend_name in backends: + return backends[backend_name] + + # Fallback to ripgrep if available (no index needed) + if 'ripgrep' in backends: + return backends['ripgrep'] + + # No backends found + available = list(backends.keys()) + raise RuntimeError( + f'Search backend "{backend_name}" not found. ' + f'Available backends: {available or "none"}' + ) + @enforce_types -def flush_search_index(snapshots: QuerySet): +def query_search_index(query: str) -> QuerySet: + """ + Search for snapshots matching the query. + + Returns a QuerySet of Snapshot objects matching the search. + """ + from core.models import Snapshot + + if not SEARCH_BACKEND_CONFIG.USE_SEARCHING_BACKEND: + return Snapshot.objects.none() + + backend = get_backend() + try: + snapshot_pks = backend.search(query) + except Exception as err: + stderr() + stderr( + f'[X] The search backend threw an exception={err}:', + color='red', + ) + raise + else: + return Snapshot.objects.filter(pk__in=snapshot_pks) + + +@enforce_types +def flush_search_index(snapshots: QuerySet) -> None: + """ + Remove snapshots from the search index. + """ if not SEARCH_BACKEND_CONFIG.USE_INDEXING_BACKEND or not snapshots: return - backend = import_backend() - snapshot_pks = (str(pk) for pk in snapshots.values_list('pk', flat=True)) + + backend = get_backend() + snapshot_pks = [str(pk) for pk in snapshots.values_list('pk', flat=True)] + try: backend.flush(snapshot_pks) except Exception as err: stderr() stderr( f'[X] The search backend threw an exception={err}:', - color='red', + color='red', ) - -@enforce_types -def index_links(links: Union[List[Link],None], out_dir: Path=settings.DATA_DIR): - if not links: - return - - from core.models import Snapshot, ArchiveResult - - for link in links: - snap = Snapshot.objects.filter(url=link.url).first() - if snap: - results = ArchiveResult.objects.indexable().filter(snapshot=snap) - log_index_started(link.url) - try: - texts = get_indexable_content(results) - except Exception as err: - stderr() - stderr( - f'[X] An Exception ocurred reading the indexable content={err}:', - color='red', - ) - else: - write_search_index(link, texts, out_dir=out_dir) diff --git a/archivebox/pkgs/abx-plugin-default-binproviders/README.md b/archivebox/tests/__init__.py similarity index 100% rename from archivebox/pkgs/abx-plugin-default-binproviders/README.md rename to archivebox/tests/__init__.py diff --git a/archivebox/tests/tests_migrations.py b/archivebox/tests/tests_migrations.py new file mode 100644 index 00000000..abf923ed --- /dev/null +++ b/archivebox/tests/tests_migrations.py @@ -0,0 +1,1004 @@ +#!/usr/bin/env python3 +""" +Migration tests for ArchiveBox. + +Tests that data directories from older versions can be migrated to newer versions +without data loss. Supports testing from 0.4.x (first Django version) to latest. + +Run with: pytest archivebox/cli/tests_migrations.py -v + +Schema Evolution: +- 0.4.x: Snapshot (tags as comma-separated string), no Tag model, no ArchiveResult +- 0.6.x: Added Tag model, Snapshot.tags became ManyToMany, added ArchiveResult +- 0.7.x: Same as 0.6.x with minor field additions +- 0.8.x: Added status fields, renamed datetime fields, added Crawl/Seed models, + changed primary keys from AutoField to UUID for Tag/ArchiveResult +""" + +__package__ = 'archivebox.cli' + +import os +import sys +import json +import shutil +import sqlite3 +import tempfile +import subprocess +import unittest +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Any, Tuple +from uuid import uuid4 + + +# ============================================================================= +# Schema Definitions for Each Version +# ============================================================================= + +# Represents the minimum schema needed for each major version +# These are simplified - real migrations handle edge cases + +SCHEMA_0_4 = """ +-- Django system tables (minimal) +CREATE TABLE IF NOT EXISTS django_migrations ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + app VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + applied DATETIME NOT NULL +); + +-- Core tables for 0.4.x +CREATE TABLE IF NOT EXISTS core_snapshot ( + id CHAR(32) PRIMARY KEY, + url VARCHAR(2000) NOT NULL UNIQUE, + timestamp VARCHAR(32) NOT NULL UNIQUE, + title VARCHAR(128), + tags VARCHAR(256), + added DATETIME NOT NULL, + updated DATETIME +); +CREATE INDEX IF NOT EXISTS core_snapshot_url ON core_snapshot(url); +CREATE INDEX IF NOT EXISTS core_snapshot_timestamp ON core_snapshot(timestamp); +CREATE INDEX IF NOT EXISTS core_snapshot_added ON core_snapshot(added); +""" + +SCHEMA_0_7 = """ +-- Django system tables +CREATE TABLE IF NOT EXISTS django_migrations ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + app VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + applied DATETIME NOT NULL +); + +CREATE TABLE IF NOT EXISTS django_content_type ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + app_label VARCHAR(100) NOT NULL, + model VARCHAR(100) NOT NULL +); + +CREATE TABLE IF NOT EXISTS auth_user ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + password VARCHAR(128) NOT NULL, + last_login DATETIME, + is_superuser BOOL NOT NULL, + username VARCHAR(150) NOT NULL UNIQUE, + first_name VARCHAR(150) NOT NULL, + last_name VARCHAR(150) NOT NULL, + email VARCHAR(254) NOT NULL, + is_staff BOOL NOT NULL, + is_active BOOL NOT NULL, + date_joined DATETIME NOT NULL +); + +-- Core tables for 0.7.x +CREATE TABLE IF NOT EXISTS core_tag ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name VARCHAR(100) NOT NULL UNIQUE, + slug VARCHAR(100) NOT NULL UNIQUE +); + +CREATE TABLE IF NOT EXISTS core_snapshot ( + id CHAR(32) PRIMARY KEY, + url VARCHAR(2000) NOT NULL UNIQUE, + timestamp VARCHAR(32) NOT NULL UNIQUE, + title VARCHAR(512), + added DATETIME NOT NULL, + updated DATETIME +); +CREATE INDEX IF NOT EXISTS core_snapshot_url ON core_snapshot(url); +CREATE INDEX IF NOT EXISTS core_snapshot_timestamp ON core_snapshot(timestamp); +CREATE INDEX IF NOT EXISTS core_snapshot_added ON core_snapshot(added); + +-- Many-to-many for snapshot tags +CREATE TABLE IF NOT EXISTS core_snapshot_tags ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + snapshot_id CHAR(32) NOT NULL REFERENCES core_snapshot(id), + tag_id INTEGER NOT NULL REFERENCES core_tag(id), + UNIQUE(snapshot_id, tag_id) +); + +CREATE TABLE IF NOT EXISTS core_archiveresult ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + uuid CHAR(32) NOT NULL, + snapshot_id CHAR(32) NOT NULL REFERENCES core_snapshot(id), + extractor VARCHAR(32) NOT NULL, + cmd TEXT, + pwd VARCHAR(256), + cmd_version VARCHAR(128), + output VARCHAR(1024), + start_ts DATETIME, + end_ts DATETIME, + status VARCHAR(16) NOT NULL +); +CREATE INDEX IF NOT EXISTS core_archiveresult_snapshot ON core_archiveresult(snapshot_id); +CREATE INDEX IF NOT EXISTS core_archiveresult_extractor ON core_archiveresult(extractor); +""" + + +# ============================================================================= +# Test Data Generators +# ============================================================================= + +def generate_uuid() -> str: + """Generate a UUID string without dashes for SQLite.""" + return uuid4().hex + + +def generate_timestamp() -> str: + """Generate a timestamp string like ArchiveBox uses.""" + return datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S') + '.000000' + + +def seed_0_4_data(db_path: Path) -> Dict[str, List[Dict]]: + """Seed a 0.4.x database with realistic test data.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + + # Track created data for verification + created_data = { + 'snapshots': [], + 'tags_str': [], # Tags are stored as comma-separated strings in 0.4.x + } + + # Create 5 snapshots with various data + test_urls = [ + ('https://example.com/page1', 'Example Page 1', 'news,tech'), + ('https://example.org/article', 'Article Title', 'blog,reading'), + ('https://github.com/user/repo', 'GitHub Repository', 'code,github'), + ('https://news.ycombinator.com/item?id=12345', 'HN Discussion', 'news,discussion'), + ('https://en.wikipedia.org/wiki/Test', 'Wikipedia Test', 'reference,wiki'), + ] + + for i, (url, title, tags) in enumerate(test_urls): + snapshot_id = generate_uuid() + timestamp = f'2024010{i+1}120000.000000' + added = f'2024-01-0{i+1} 12:00:00' + + cursor.execute(""" + INSERT INTO core_snapshot (id, url, timestamp, title, tags, added, updated) + VALUES (?, ?, ?, ?, ?, ?, ?) + """, (snapshot_id, url, timestamp, title, tags, added, added)) + + created_data['snapshots'].append({ + 'id': snapshot_id, + 'url': url, + 'timestamp': timestamp, + 'title': title, + 'tags': tags, + }) + created_data['tags_str'].append(tags) + + # Record migrations as applied (0.4.x had just the initial migration) + cursor.execute(""" + INSERT INTO django_migrations (app, name, applied) + VALUES ('core', '0001_initial', datetime('now')) + """) + + conn.commit() + conn.close() + + return created_data + + +def seed_0_7_data(db_path: Path) -> Dict[str, List[Dict]]: + """Seed a 0.7.x database with realistic test data.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + + created_data = { + 'users': [], + 'snapshots': [], + 'tags': [], + 'archiveresults': [], + } + + # Create a user + cursor.execute(""" + INSERT INTO auth_user (password, is_superuser, username, first_name, last_name, + email, is_staff, is_active, date_joined) + VALUES ('pbkdf2_sha256$test', 1, 'admin', 'Admin', 'User', + 'admin@example.com', 1, 1, datetime('now')) + """) + user_id = cursor.lastrowid + created_data['users'].append({'id': user_id, 'username': 'admin'}) + + # Create 5 tags + tag_names = ['news', 'tech', 'blog', 'reference', 'code'] + for name in tag_names: + cursor.execute(""" + INSERT INTO core_tag (name, slug) VALUES (?, ?) + """, (name, name.lower())) + tag_id = cursor.lastrowid + created_data['tags'].append({'id': tag_id, 'name': name, 'slug': name.lower()}) + + # Create 5 snapshots + test_urls = [ + ('https://example.com/page1', 'Example Page 1'), + ('https://example.org/article', 'Article Title'), + ('https://github.com/user/repo', 'GitHub Repository'), + ('https://news.ycombinator.com/item?id=12345', 'HN Discussion'), + ('https://en.wikipedia.org/wiki/Test', 'Wikipedia Test'), + ] + + for i, (url, title) in enumerate(test_urls): + snapshot_id = generate_uuid() + timestamp = f'2024010{i+1}120000.000000' + added = f'2024-01-0{i+1} 12:00:00' + + cursor.execute(""" + INSERT INTO core_snapshot (id, url, timestamp, title, added, updated) + VALUES (?, ?, ?, ?, ?, ?) + """, (snapshot_id, url, timestamp, title, added, added)) + + created_data['snapshots'].append({ + 'id': snapshot_id, + 'url': url, + 'timestamp': timestamp, + 'title': title, + }) + + # Assign 2 random tags to each snapshot + tag_ids = [created_data['tags'][i % 5]['id'], created_data['tags'][(i + 1) % 5]['id']] + for tag_id in tag_ids: + cursor.execute(""" + INSERT INTO core_snapshot_tags (snapshot_id, tag_id) VALUES (?, ?) + """, (snapshot_id, tag_id)) + + # Create 5 archive results for each snapshot + extractors = ['title', 'favicon', 'screenshot', 'singlefile', 'wget'] + statuses = ['succeeded', 'succeeded', 'failed', 'succeeded', 'skipped'] + + for j, (extractor, status) in enumerate(zip(extractors, statuses)): + result_uuid = generate_uuid() + cursor.execute(""" + INSERT INTO core_archiveresult + (uuid, snapshot_id, extractor, cmd, pwd, cmd_version, output, start_ts, end_ts, status) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, ( + result_uuid, snapshot_id, extractor, + json.dumps([extractor, '--version']), + f'/data/archive/{timestamp}', + '1.0.0', + f'{extractor}/index.html' if status == 'succeeded' else '', + f'2024-01-0{i+1} 12:00:0{j}', + f'2024-01-0{i+1} 12:00:1{j}', + status + )) + + created_data['archiveresults'].append({ + 'uuid': result_uuid, + 'snapshot_id': snapshot_id, + 'extractor': extractor, + 'status': status, + }) + + # Record migrations as applied (0.7.x migrations up to 0021) + migrations = [ + ('core', '0001_initial'), + ('core', '0002_auto_20200625_1521'), + ('core', '0003_auto_20200630_1034'), + ('core', '0004_auto_20200713_1552'), + ('core', '0005_auto_20200728_0326'), + ('core', '0006_auto_20201012_1520'), + ('core', '0007_archiveresult'), + ('core', '0008_auto_20210105_1421'), + ('core', '0009_auto_20210216_1038'), + ('core', '0010_auto_20210216_1055'), + ('core', '0011_auto_20210216_1331'), + ('core', '0012_auto_20210216_1425'), + ('core', '0013_auto_20210218_0729'), + ('core', '0014_auto_20210218_0729'), + ('core', '0015_auto_20210218_0730'), + ('core', '0016_auto_20210218_1204'), + ('core', '0017_auto_20210219_0211'), + ('core', '0018_auto_20210327_0952'), + ('core', '0019_auto_20210401_0654'), + ('core', '0020_auto_20210410_1031'), + ('core', '0021_auto_20220914_0934'), + ] + + for app, name in migrations: + cursor.execute(""" + INSERT INTO django_migrations (app, name, applied) + VALUES (?, ?, datetime('now')) + """, (app, name)) + + conn.commit() + conn.close() + + return created_data + + +# ============================================================================= +# Helper Functions +# ============================================================================= + +def run_archivebox(data_dir: Path, args: list, timeout: int = 120) -> subprocess.CompletedProcess: + """Run archivebox command in subprocess with given data directory.""" + env = os.environ.copy() + env['DATA_DIR'] = str(data_dir) + env['USE_COLOR'] = 'False' + env['SHOW_PROGRESS'] = 'False' + # Disable slow extractors for tests + env['SAVE_ARCHIVE_DOT_ORG'] = 'False' + env['SAVE_TITLE'] = 'False' + env['SAVE_FAVICON'] = 'False' + env['SAVE_WGET'] = 'False' + env['SAVE_SINGLEFILE'] = 'False' + env['SAVE_SCREENSHOT'] = 'False' + env['SAVE_PDF'] = 'False' + env['SAVE_DOM'] = 'False' + env['SAVE_READABILITY'] = 'False' + env['SAVE_MERCURY'] = 'False' + env['SAVE_GIT'] = 'False' + env['SAVE_MEDIA'] = 'False' + env['SAVE_HEADERS'] = 'False' + + cmd = [sys.executable, '-m', 'archivebox'] + args + + return subprocess.run( + cmd, + capture_output=True, + text=True, + env=env, + cwd=str(data_dir), + timeout=timeout, + ) + + +def create_data_dir_structure(data_dir: Path): + """Create the basic ArchiveBox data directory structure.""" + (data_dir / 'archive').mkdir(parents=True, exist_ok=True) + (data_dir / 'sources').mkdir(parents=True, exist_ok=True) + (data_dir / 'logs').mkdir(parents=True, exist_ok=True) + + +def verify_snapshot_count(db_path: Path, expected: int) -> Tuple[bool, str]: + """Verify the number of snapshots in the database.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM core_snapshot") + count = cursor.fetchone()[0] + conn.close() + + if count == expected: + return True, f"Snapshot count OK: {count}" + return False, f"Snapshot count mismatch: expected {expected}, got {count}" + + +def verify_tag_count(db_path: Path, expected: int) -> Tuple[bool, str]: + """Verify the number of tags in the database.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM core_tag") + count = cursor.fetchone()[0] + conn.close() + + if count >= expected: # May have more due to tag splitting + return True, f"Tag count OK: {count} (expected >= {expected})" + return False, f"Tag count mismatch: expected >= {expected}, got {count}" + + +def verify_archiveresult_count(db_path: Path, expected: int) -> Tuple[bool, str]: + """Verify the number of archive results in the database.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM core_archiveresult") + count = cursor.fetchone()[0] + conn.close() + + if count == expected: + return True, f"ArchiveResult count OK: {count}" + return False, f"ArchiveResult count mismatch: expected {expected}, got {count}" + + +def verify_snapshot_urls(db_path: Path, expected_urls: List[str]) -> Tuple[bool, str]: + """Verify all expected URLs exist in snapshots.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT url FROM core_snapshot") + actual_urls = {row[0] for row in cursor.fetchall()} + conn.close() + + missing = set(expected_urls) - actual_urls + if not missing: + return True, "All URLs preserved" + return False, f"Missing URLs: {missing}" + + +def verify_snapshot_titles(db_path: Path, expected_titles: Dict[str, str]) -> Tuple[bool, str]: + """Verify snapshot titles are preserved.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT url, title FROM core_snapshot") + actual = {row[0]: row[1] for row in cursor.fetchall()} + conn.close() + + mismatches = [] + for url, expected_title in expected_titles.items(): + if url in actual and actual[url] != expected_title: + mismatches.append(f"{url}: expected '{expected_title}', got '{actual[url]}'") + + if not mismatches: + return True, "All titles preserved" + return False, f"Title mismatches: {mismatches}" + + +def verify_foreign_keys(db_path: Path) -> Tuple[bool, str]: + """Verify foreign key relationships are intact.""" + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + + # Check ArchiveResult -> Snapshot FK + cursor.execute(""" + SELECT COUNT(*) FROM core_archiveresult ar + WHERE NOT EXISTS (SELECT 1 FROM core_snapshot s WHERE s.id = ar.snapshot_id) + """) + orphaned_results = cursor.fetchone()[0] + + conn.close() + + if orphaned_results == 0: + return True, "Foreign keys intact" + return False, f"Found {orphaned_results} orphaned ArchiveResults" + + +# ============================================================================= +# Test Classes +# ============================================================================= + +class TestFreshInstall(unittest.TestCase): + """Test that fresh installs work correctly.""" + + def test_init_creates_database(self): + """Fresh init should create database and directories.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0, f"Init failed: {result.stderr}") + + # Verify database was created + self.assertTrue((work_dir / 'index.sqlite3').exists(), "Database not created") + # Verify archive directory exists + self.assertTrue((work_dir / 'archive').is_dir(), "Archive dir not created") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_status_after_init(self): + """Status command should work after init.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + result = run_archivebox(work_dir, ['status']) + self.assertEqual(result.returncode, 0, f"Status failed: {result.stderr}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_add_url_after_init(self): + """Should be able to add URLs after init. + + In the new architecture, 'archivebox add' creates: + 1. A sources file containing the URLs + 2. A Seed pointing to the sources file + 3. A Crawl with max_depth + 4. A root Snapshot with file:// URL + 5. Parser extractors discover URLs and create child Snapshots + """ + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + # Add a URL (with extractors disabled, should be fast) + result = run_archivebox(work_dir, ['add', 'https://example.com'], timeout=60) + # returncode 1 is ok if some extractors fail + self.assertIn(result.returncode, [0, 1], + f"Add command crashed: {result.stderr}") + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + + # Verify a Crawl was created + cursor.execute("SELECT COUNT(*) FROM crawls_crawl") + crawl_count = cursor.fetchone()[0] + self.assertGreaterEqual(crawl_count, 1, "No Crawl was created") + + # Verify a Seed was created + cursor.execute("SELECT COUNT(*) FROM crawls_seed") + seed_count = cursor.fetchone()[0] + self.assertGreaterEqual(seed_count, 1, "No Seed was created") + + # Verify at least one snapshot was created (the file:// root snapshot) + cursor.execute("SELECT COUNT(*) FROM core_snapshot") + snapshot_count = cursor.fetchone()[0] + self.assertGreaterEqual(snapshot_count, 1, "No Snapshot was created") + + # Verify the sources file contains the URL + sources_dir = work_dir / 'sources' + self.assertTrue(sources_dir.exists(), "Sources directory not created") + source_files = list(sources_dir.glob('*.txt')) + self.assertGreater(len(source_files), 0, "No source files created") + + # Check that URL is in at least one source file + found_url = False + for source_file in source_files: + content = source_file.read_text() + if 'example.com' in content: + found_url = True + break + self.assertTrue(found_url, "URL not found in source files") + + conn.close() + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_list_after_add(self): + """List/search command should show added snapshots. + + In the new architecture, the root snapshot is a file:// URL pointing + to the sources file that contains the actual URLs. + """ + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + result = run_archivebox(work_dir, ['add', 'https://example.com'], timeout=60) + self.assertIn(result.returncode, [0, 1]) + + # 'list' is renamed to 'search' in the new CLI + result = run_archivebox(work_dir, ['search']) + self.assertEqual(result.returncode, 0, f"Search failed: {result.stderr}") + + # The root snapshot is a file:// URL, so we check for sources file path + # or at least that there's some output + output = result.stdout + result.stderr + # Should have at least one snapshot listed (the file:// root) + self.assertTrue( + 'file://' in output or 'sources' in output or 'cli_add' in output, + f"No snapshot shown in search output: {output[:500]}" + ) + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_migrations_table_populated(self): + """Django migrations table should be populated after init.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM django_migrations") + count = cursor.fetchone()[0] + conn.close() + + # Should have many migrations applied + self.assertGreater(count, 10, f"Expected >10 migrations, got {count}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_core_migrations_applied(self): + """Core app migrations should be applied.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + cursor.execute("SELECT name FROM django_migrations WHERE app='core' ORDER BY name") + migrations = [row[0] for row in cursor.fetchall()] + conn.close() + + self.assertIn('0001_initial', migrations) + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + +class TestSchemaIntegrity(unittest.TestCase): + """Test that the database schema is correct.""" + + def test_snapshot_table_has_required_columns(self): + """Snapshot table should have all required columns.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + cursor.execute('PRAGMA table_info(core_snapshot)') + columns = {row[1] for row in cursor.fetchall()} + conn.close() + + required = {'id', 'url', 'timestamp', 'title', 'status', 'created_at', 'modified_at'} + for col in required: + self.assertIn(col, columns, f"Missing column: {col}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_archiveresult_table_has_required_columns(self): + """ArchiveResult table should have all required columns.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + cursor.execute('PRAGMA table_info(core_archiveresult)') + columns = {row[1] for row in cursor.fetchall()} + conn.close() + + required = {'id', 'snapshot_id', 'extractor', 'status', 'created_at', 'modified_at'} + for col in required: + self.assertIn(col, columns, f"Missing column: {col}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_tag_table_has_required_columns(self): + """Tag table should have all required columns.""" + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + cursor.execute('PRAGMA table_info(core_tag)') + columns = {row[1] for row in cursor.fetchall()} + conn.close() + + required = {'id', 'name', 'slug'} + for col in required: + self.assertIn(col, columns, f"Missing column: {col}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + +class TestMultipleSnapshots(unittest.TestCase): + """Test handling multiple snapshots.""" + + def test_add_multiple_urls(self): + """Should be able to add multiple URLs. + + Each 'archivebox add' call creates: + - 1 Crawl + - 1 Seed + - 1 root Snapshot (file:// URL pointing to sources file) + """ + work_dir = Path(tempfile.mkdtemp()) + + try: + result = run_archivebox(work_dir, ['init']) + self.assertEqual(result.returncode, 0) + + # Add multiple URLs (each in separate add calls) + for url in ['https://example.com', 'https://example.org']: + result = run_archivebox(work_dir, ['add', url], timeout=60) + self.assertIn(result.returncode, [0, 1]) + + conn = sqlite3.connect(str(work_dir / 'index.sqlite3')) + cursor = conn.cursor() + + # Verify both Crawls were created + cursor.execute("SELECT COUNT(*) FROM crawls_crawl") + crawl_count = cursor.fetchone()[0] + self.assertEqual(crawl_count, 2, f"Expected 2 Crawls, got {crawl_count}") + + # Verify both root Snapshots were created + cursor.execute("SELECT COUNT(*) FROM core_snapshot") + snapshot_count = cursor.fetchone()[0] + self.assertGreaterEqual(snapshot_count, 2, f"Expected >=2 snapshots, got {snapshot_count}") + + conn.close() + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + +class TestMigrationFrom07x(unittest.TestCase): + """Test migration from 0.7.x schema to latest.""" + + def setUp(self): + """Create a temporary directory with 0.7.x schema and data.""" + self.work_dir = Path(tempfile.mkdtemp()) + self.db_path = self.work_dir / 'index.sqlite3' + + # Create directory structure + create_data_dir_structure(self.work_dir) + + # Create database with 0.7.x schema + conn = sqlite3.connect(str(self.db_path)) + conn.executescript(SCHEMA_0_7) + conn.close() + + # Seed with test data + self.original_data = seed_0_7_data(self.db_path) + + def tearDown(self): + """Clean up temporary directory.""" + shutil.rmtree(self.work_dir, ignore_errors=True) + + def test_migration_preserves_snapshot_count(self): + """Migration should preserve all snapshots.""" + expected_count = len(self.original_data['snapshots']) + + # Run init to trigger migrations + result = run_archivebox(self.work_dir, ['init'], timeout=120) + + # Check return code - may be 1 if some migrations have issues, but data should be preserved + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + # Verify snapshot count + ok, msg = verify_snapshot_count(self.db_path, expected_count) + self.assertTrue(ok, msg) + + def test_migration_preserves_snapshot_urls(self): + """Migration should preserve all snapshot URLs.""" + expected_urls = [s['url'] for s in self.original_data['snapshots']] + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_snapshot_urls(self.db_path, expected_urls) + self.assertTrue(ok, msg) + + def test_migration_preserves_snapshot_titles(self): + """Migration should preserve all snapshot titles.""" + expected_titles = {s['url']: s['title'] for s in self.original_data['snapshots']} + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_snapshot_titles(self.db_path, expected_titles) + self.assertTrue(ok, msg) + + def test_migration_preserves_tags(self): + """Migration should preserve all tags.""" + expected_count = len(self.original_data['tags']) + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_tag_count(self.db_path, expected_count) + self.assertTrue(ok, msg) + + def test_migration_preserves_archiveresults(self): + """Migration should preserve all archive results.""" + expected_count = len(self.original_data['archiveresults']) + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_archiveresult_count(self.db_path, expected_count) + self.assertTrue(ok, msg) + + def test_migration_preserves_foreign_keys(self): + """Migration should maintain foreign key relationships.""" + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_foreign_keys(self.db_path) + self.assertTrue(ok, msg) + + def test_status_works_after_migration(self): + """Status command should work after migration.""" + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1]) + + result = run_archivebox(self.work_dir, ['status']) + self.assertEqual(result.returncode, 0, f"Status failed after migration: {result.stderr}") + + def test_search_works_after_migration(self): + """Search command should find migrated snapshots.""" + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1]) + + result = run_archivebox(self.work_dir, ['search']) + self.assertEqual(result.returncode, 0, f"Search failed after migration: {result.stderr}") + + # Should find at least some of the migrated URLs + output = result.stdout + result.stderr + found_any = any(s['url'][:30] in output or s['title'] in output + for s in self.original_data['snapshots']) + self.assertTrue(found_any, f"No migrated snapshots found in search: {output[:500]}") + + +class TestMigrationFrom04x(unittest.TestCase): + """Test migration from 0.4.x schema to latest. + + 0.4.x was the first Django-powered version with a simpler schema: + - No Tag model (tags stored as comma-separated string in Snapshot) + - No ArchiveResult model (results stored in JSON files) + """ + + def setUp(self): + """Create a temporary directory with 0.4.x schema and data.""" + self.work_dir = Path(tempfile.mkdtemp()) + self.db_path = self.work_dir / 'index.sqlite3' + + # Create directory structure + create_data_dir_structure(self.work_dir) + + # Create database with 0.4.x schema + conn = sqlite3.connect(str(self.db_path)) + conn.executescript(SCHEMA_0_4) + conn.close() + + # Seed with test data + self.original_data = seed_0_4_data(self.db_path) + + def tearDown(self): + """Clean up temporary directory.""" + shutil.rmtree(self.work_dir, ignore_errors=True) + + def test_migration_preserves_snapshot_count(self): + """Migration should preserve all snapshots from 0.4.x.""" + expected_count = len(self.original_data['snapshots']) + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_snapshot_count(self.db_path, expected_count) + self.assertTrue(ok, msg) + + def test_migration_preserves_snapshot_urls(self): + """Migration should preserve all snapshot URLs from 0.4.x.""" + expected_urls = [s['url'] for s in self.original_data['snapshots']] + + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + ok, msg = verify_snapshot_urls(self.db_path, expected_urls) + self.assertTrue(ok, msg) + + def test_migration_converts_string_tags_to_model(self): + """Migration should convert comma-separated tags to Tag model instances.""" + result = run_archivebox(self.work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1], f"Init crashed: {result.stderr}") + + # Collect unique tags from original data + original_tags = set() + for tags_str in self.original_data['tags_str']: + if tags_str: + for tag in tags_str.split(','): + original_tags.add(tag.strip()) + + # Tags should have been created + ok, msg = verify_tag_count(self.db_path, len(original_tags)) + self.assertTrue(ok, msg) + + +class TestMigrationDataIntegrity(unittest.TestCase): + """Comprehensive data integrity tests for migrations.""" + + def test_no_duplicate_snapshots_after_migration(self): + """Migration should not create duplicate snapshots.""" + work_dir = Path(tempfile.mkdtemp()) + db_path = work_dir / 'index.sqlite3' + + try: + create_data_dir_structure(work_dir) + conn = sqlite3.connect(str(db_path)) + conn.executescript(SCHEMA_0_7) + conn.close() + seed_0_7_data(db_path) + + result = run_archivebox(work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1]) + + # Check for duplicate URLs + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute(""" + SELECT url, COUNT(*) as cnt FROM core_snapshot + GROUP BY url HAVING cnt > 1 + """) + duplicates = cursor.fetchall() + conn.close() + + self.assertEqual(len(duplicates), 0, f"Found duplicate URLs: {duplicates}") + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_no_orphaned_archiveresults_after_migration(self): + """Migration should not leave orphaned ArchiveResults.""" + work_dir = Path(tempfile.mkdtemp()) + db_path = work_dir / 'index.sqlite3' + + try: + create_data_dir_structure(work_dir) + conn = sqlite3.connect(str(db_path)) + conn.executescript(SCHEMA_0_7) + conn.close() + seed_0_7_data(db_path) + + result = run_archivebox(work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1]) + + ok, msg = verify_foreign_keys(db_path) + self.assertTrue(ok, msg) + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + def test_timestamps_preserved_after_migration(self): + """Migration should preserve original timestamps.""" + work_dir = Path(tempfile.mkdtemp()) + db_path = work_dir / 'index.sqlite3' + + try: + create_data_dir_structure(work_dir) + conn = sqlite3.connect(str(db_path)) + conn.executescript(SCHEMA_0_7) + conn.close() + original_data = seed_0_7_data(db_path) + + original_timestamps = {s['url']: s['timestamp'] for s in original_data['snapshots']} + + result = run_archivebox(work_dir, ['init'], timeout=120) + self.assertIn(result.returncode, [0, 1]) + + conn = sqlite3.connect(str(db_path)) + cursor = conn.cursor() + cursor.execute("SELECT url, timestamp FROM core_snapshot") + migrated_timestamps = {row[0]: row[1] for row in cursor.fetchall()} + conn.close() + + for url, original_ts in original_timestamps.items(): + self.assertEqual( + migrated_timestamps.get(url), original_ts, + f"Timestamp changed for {url}: {original_ts} -> {migrated_timestamps.get(url)}" + ) + + finally: + shutil.rmtree(work_dir, ignore_errors=True) + + +if __name__ == '__main__': + unittest.main() diff --git a/archivebox/workers/__init__.py b/archivebox/workers/__init__.py index 9ced0d60..a2e523ab 100644 --- a/archivebox/workers/__init__.py +++ b/archivebox/workers/__init__.py @@ -1,9 +1,7 @@ __package__ = 'archivebox.workers' __order__ = 100 -import abx -@abx.hookimpl def register_admin(admin_site): from workers.admin import register_admin register_admin(admin_site) diff --git a/archivebox/workers/actor.py b/archivebox/workers/actor.py deleted file mode 100644 index d0d6215d..00000000 --- a/archivebox/workers/actor.py +++ /dev/null @@ -1,166 +0,0 @@ -# __package__ = 'archivebox.workers' - -# import time - - -# from typing import ClassVar, Type, Iterable, TypedDict -# from django.db.models import QuerySet -# from django.db import transaction -# from django.utils import timezone -# from django.utils.functional import classproperty # type: ignore - -# from .models import Event, Process, EventDict - - -# class ActorType: -# # static class attributes -# name: ClassVar[str] -# event_prefix: ClassVar[str] -# poll_interval: ClassVar[int] = 1 - -# @classproperty -# def event_queue(cls) -> QuerySet[Event]: -# return Event.objects.filter(type__startswith=cls.event_prefix) - -# @classmethod -# def fork(cls, wait_for_first_event=False, exit_on_idle=True) -> Process: -# cmd = ['archivebox', 'actor', cls.name] -# if exit_on_idle: -# cmd.append('--exit-on-idle') -# if wait_for_first_event: -# cmd.append('--wait-for-first-event') -# return Process.create_and_fork(cmd=cmd, actor_type=cls.name) - -# @classproperty -# def processes(cls) -> QuerySet[Process]: -# return Process.objects.filter(actor_type=cls.name) - -# @classmethod -# def run(cls, wait_for_first_event=False, exit_on_idle=True): - -# if wait_for_first_event: -# event = cls.event_queue.get_next_unclaimed() -# while not event: -# time.sleep(cls.poll_interval) -# event = cls.event_queue.get_next_unclaimed() - -# while True: -# output_events = list(cls.process_next_event()) or list(cls.process_idle_tick()) # process next event, or tick if idle -# yield from output_events -# if not output_events: -# if exit_on_idle: -# break -# else: -# time.sleep(cls.poll_interval) - -# @classmethod -# def process_next_event(cls) -> Iterable[EventDict]: -# event = cls.event_queue.get_next_unclaimed() -# output_events = [] - -# if not event: -# return [] - -# cls.mark_event_claimed(event, duration=60) -# try: -# for output_event in cls.receive(event): -# output_events.append(output_event) -# yield output_event -# cls.mark_event_succeeded(event, output_events=output_events) -# except BaseException as e: -# cls.mark_event_failed(event, output_events=output_events, error=e) - -# @classmethod -# def process_idle_tick(cls) -> Iterable[EventDict]: -# # reset the idle event to be claimed by the current process -# event, _created = Event.objects.update_or_create( -# name=f'{cls.event_prefix}IDLE', -# emitted_by=Process.current(), -# defaults={ -# 'deliver_at': timezone.now(), -# 'claimed_proc': None, -# 'claimed_at': None, -# 'finished_at': None, -# 'error': None, -# 'parent': None, -# }, -# ) - -# # then process it like any other event -# yield from cls.process_next_event() - -# @classmethod -# def receive(cls, event: Event) -> Iterable[EventDict]: -# handler_method = getattr(cls, f'on_{event.name}', None) -# if handler_method: -# yield from handler_method(event) -# else: -# raise Exception(f'No handler method for event: {event.name}') - -# @staticmethod -# def on_IDLE() -> Iterable[EventDict]: -# return [] - -# @staticmethod -# def mark_event_claimed(event: Event, duration: int=60): -# proc = Process.current() - -# with transaction.atomic(): -# claimed = Event.objects.filter(id=event.id, claimed_proc=None, claimed_at=None).update(claimed_proc=proc, claimed_at=timezone.now()) -# if not claimed: -# event.refresh_from_db() -# raise Exception(f'Event already claimed by another process: {event.claimed_proc}') - -# process_updated = Process.objects.filter(id=proc.id, active_event=None).update(active_event=event) -# if not process_updated: -# raise Exception(f'Unable to update process.active_event: {proc}.active_event = {event}') - -# @staticmethod -# def mark_event_succeeded(event: Event, output_events: Iterable[EventDict]): -# assert event.claimed_proc and (event.claimed_proc == Process.current()) -# with transaction.atomic(): -# updated = Event.objects.filter(id=event.id, claimed_proc=event.claimed_proc, claimed_at=event.claimed_at, finished_at=None).update(finished_at=timezone.now()) -# if not updated: -# event.refresh_from_db() -# raise Exception(f'Event {event} failed to mark as succeeded, it was modified by another process: {event.claimed_proc}') - -# process_updated = Process.objects.filter(id=event.claimed_proc.id, active_event=event).update(active_event=None) -# if not process_updated: -# raise Exception(f'Unable to unset process.active_event: {event.claimed_proc}.active_event = {event}') - -# # dispatch any output events -# for output_event in output_events: -# Event.dispatch(event=output_event, parent=event) - -# # trigger any callback events -# if event.on_success: -# Event.dispatch(event=event.on_success, parent=event) - -# @staticmethod -# def mark_event_failed(event: Event, output_events: Iterable[EventDict]=(), error: BaseException | None = None): -# assert event.claimed_proc and (event.claimed_proc == Process.current()) -# with transaction.atomic(): -# updated = event.objects.filter(id=event.id, claimed_proc=event.claimed_proc, claimed_at=event.claimed_at, finished_at=None).update(finished_at=timezone.now(), error=str(error)) -# if not updated: -# event.refresh_from_db() -# raise Exception(f'Event {event} failed to mark as failed, it was modified by another process: {event.claimed_proc}') - -# process_updated = Process.objects.filter(id=event.claimed_proc.id, active_event=event).update(active_event=None) -# if not process_updated: -# raise Exception(f'Unable to unset process.active_event: {event.claimed_proc}.active_event = {event}') - - -# # add dedicated error event to the output events -# output_events = [ -# *output_events, -# {'name': f'{event.name}_ERROR', 'error': f'{type(error).__name__}: {error}'}, -# ] - -# # dispatch any output events -# for output_event in output_events: -# Event.dispatch(event=output_event, parent=event) - -# # trigger any callback events -# if event.on_failure: -# Event.dispatch(event=event.on_failure, parent=event) - diff --git a/archivebox/workers/admin.py b/archivebox/workers/admin.py index dc7d8958..40aaeade 100644 --- a/archivebox/workers/admin.py +++ b/archivebox/workers/admin.py @@ -1,7 +1,5 @@ __package__ = 'archivebox.workers' -import abx - from django.contrib.auth import get_permission_codename from huey_monitor.apps import HueyMonitorConfig @@ -20,7 +18,6 @@ class CustomTaskModelAdmin(TaskModelAdmin): -@abx.hookimpl def register_admin(admin_site): admin_site.register(TaskModel, CustomTaskModelAdmin) admin_site.register(SignalInfoModel, SignalInfoModelAdmin) diff --git a/archivebox/workers/management/commands/orchestrator.py b/archivebox/workers/management/commands/orchestrator.py deleted file mode 100644 index e74170b3..00000000 --- a/archivebox/workers/management/commands/orchestrator.py +++ /dev/null @@ -1,18 +0,0 @@ - - -from django.core.management.base import BaseCommand - -from workers.orchestrator import ArchivingOrchestrator - - -class Command(BaseCommand): - help = 'Run the archivebox orchestrator' - - # def add_arguments(self, parser): - # parser.add_argument('subcommand', type=str, help='The subcommand you want to run') - # parser.add_argument('command_args', nargs='*', help='Arguments to pass to the subcommand') - - - def handle(self, *args, **kwargs): - orchestrator = ArchivingOrchestrator() - orchestrator.start() diff --git a/archivebox/workers/models.py b/archivebox/workers/models.py index e10a5d0f..438d241a 100644 --- a/archivebox/workers/models.py +++ b/archivebox/workers/models.py @@ -1,20 +1,14 @@ __package__ = 'archivebox.workers' -import uuid -import json - -from typing import ClassVar, Type, Iterable, TypedDict +from typing import ClassVar, Type, Iterable from datetime import datetime, timedelta from statemachine.mixins import MachineMixin from django.db import models -from django.db.models import QuerySet from django.core import checks from django.utils import timezone from django.utils.functional import classproperty -from machine.models import Process - from statemachine import registry, StateMachine, State @@ -33,31 +27,31 @@ ObjectStateList = Iterable[ObjectState] class BaseModelWithStateMachine(models.Model, MachineMixin): id: models.UUIDField - + StatusChoices: ClassVar[Type[models.TextChoices]] - + # status: models.CharField # retry_at: models.DateTimeField - + state_machine_name: ClassVar[str] state_field_name: ClassVar[str] state_machine_attr: ClassVar[str] = 'sm' bind_events_as_methods: ClassVar[bool] = True - + active_state: ClassVar[ObjectState] retry_at_field_name: ClassVar[str] - + class Meta: abstract = True - + @classmethod def check(cls, sender=None, **kwargs): errors = super().check(**kwargs) - + found_id_field = False found_status_field = False found_retry_at_field = False - + for field in cls._meta.get_fields(): if getattr(field, '_is_state_field', False): if cls.state_field_name == field.name: @@ -74,7 +68,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): found_retry_at_field = True if field.name == 'id' and getattr(field, 'primary_key', False): found_id_field = True - + if not found_status_field: errors.append(checks.Error( f'{cls.__name__}.state_field_name must be defined and point to a StatusField()', @@ -89,7 +83,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E013', )) - + if not found_id_field: errors.append(checks.Error( f'{cls.__name__} must have an id field that is a primary key', @@ -97,7 +91,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E014', )) - + if not isinstance(cls.state_machine_name, str): errors.append(checks.Error( f'{cls.__name__}.state_machine_name must be a dotted-import path to a StateMachine class', @@ -105,7 +99,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E015', )) - + try: cls.StateMachineClass except Exception as err: @@ -115,7 +109,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E016', )) - + if cls.INITIAL_STATE not in cls.StatusChoices.values: errors.append(checks.Error( f'{cls.__name__}.StateMachineClass.initial_state must be present within {cls.__name__}.StatusChoices', @@ -123,7 +117,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E017', )) - + if cls.ACTIVE_STATE not in cls.StatusChoices.values: errors.append(checks.Error( f'{cls.__name__}.active_state must be set to a valid State present within {cls.__name__}.StatusChoices', @@ -131,8 +125,8 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): obj=cls, id='workers.E018', )) - - + + for state in cls.FINAL_STATES: if state not in cls.StatusChoices.values: errors.append(checks.Error( @@ -143,55 +137,106 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): )) break return errors - + @staticmethod def _state_to_str(state: ObjectState) -> str: """Convert a statemachine.State, models.TextChoices.choices value, or Enum value to a str""" return str(state.value) if isinstance(state, State) else str(state) - - + + @property def RETRY_AT(self) -> datetime: return getattr(self, self.retry_at_field_name) - + @RETRY_AT.setter def RETRY_AT(self, value: datetime): setattr(self, self.retry_at_field_name, value) - + @property def STATE(self) -> str: return getattr(self, self.state_field_name) - + @STATE.setter def STATE(self, value: str): setattr(self, self.state_field_name, value) - + def bump_retry_at(self, seconds: int = 10): self.RETRY_AT = timezone.now() + timedelta(seconds=seconds) - + + def update_for_workers(self, **kwargs) -> bool: + """ + Atomically update the object's fields for worker processing. + Returns True if the update was successful, False if the object was modified by another worker. + """ + # Get the current retry_at to use as optimistic lock + current_retry_at = self.RETRY_AT + + # Apply the updates + for key, value in kwargs.items(): + setattr(self, key, value) + + # Try to save with optimistic locking + updated = type(self).objects.filter( + pk=self.pk, + retry_at=current_retry_at, + ).update(**{k: getattr(self, k) for k in kwargs}) + + if updated == 1: + self.refresh_from_db() + return True + return False + + @classmethod + def get_queue(cls): + """ + Get the sorted and filtered QuerySet of objects that are ready for processing. + Objects are ready if: + - status is not in FINAL_STATES + - retry_at is in the past (or now) + """ + return cls.objects.filter( + retry_at__lte=timezone.now() + ).exclude( + status__in=cls.FINAL_STATES + ).order_by('retry_at') + + @classmethod + def claim_for_worker(cls, obj: 'BaseModelWithStateMachine', lock_seconds: int = 60) -> bool: + """ + Atomically claim an object for processing using optimistic locking. + Returns True if successfully claimed, False if another worker got it first. + """ + updated = cls.objects.filter( + pk=obj.pk, + retry_at=obj.retry_at, + ).update( + retry_at=timezone.now() + timedelta(seconds=lock_seconds) + ) + return updated == 1 + @classproperty def ACTIVE_STATE(cls) -> str: return cls._state_to_str(cls.active_state) - + @classproperty def INITIAL_STATE(cls) -> str: return cls._state_to_str(cls.StateMachineClass.initial_state) - + @classproperty def FINAL_STATES(cls) -> list[str]: return [cls._state_to_str(state) for state in cls.StateMachineClass.final_states] - + @classproperty def FINAL_OR_ACTIVE_STATES(cls) -> list[str]: return [*cls.FINAL_STATES, cls.ACTIVE_STATE] - + @classmethod def extend_choices(cls, base_choices: Type[models.TextChoices]): """ Decorator to extend the base choices with extra choices, e.g.: - + class MyModel(ModelWithStateMachine): - + @ModelWithStateMachine.extend_choices(ModelWithStateMachine.StatusChoices) class StatusChoices(models.TextChoices): SUCCEEDED = 'succeeded' @@ -207,12 +252,12 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): joined[item[0]] = item[1] return models.TextChoices('StatusChoices', joined) return wrapper - + @classmethod def StatusField(cls, **kwargs) -> models.CharField: """ Used on subclasses to extend/modify the status field with updated kwargs. e.g.: - + class MyModel(ModelWithStateMachine): class StatusChoices(ModelWithStateMachine.StatusChoices): QUEUED = 'queued', 'Queued' @@ -221,7 +266,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): BACKOFF = 'backoff', 'Backoff' FAILED = 'failed', 'Failed' SKIPPED = 'skipped', 'Skipped' - + status = ModelWithStateMachine.StatusField(choices=StatusChoices.choices, default=StatusChoices.QUEUED) """ default_kwargs = default_status_field.deconstruct()[3] @@ -234,7 +279,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): def RetryAtField(cls, **kwargs) -> models.DateTimeField: """ Used on subclasses to extend/modify the retry_at field with updated kwargs. e.g.: - + class MyModel(ModelWithStateMachine): retry_at = ModelWithStateMachine.RetryAtField(editable=False) """ @@ -243,7 +288,7 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): field = models.DateTimeField(**updated_kwargs) field._is_retry_at_field = True # type: ignore return field - + @classproperty def StateMachineClass(cls) -> Type[StateMachine]: """Get the StateMachine class for the given django Model that inherits from MachineMixin""" @@ -254,271 +299,21 @@ class BaseModelWithStateMachine(models.Model, MachineMixin): assert issubclass(StateMachineCls, StateMachine) return StateMachineCls raise NotImplementedError(f'ActorType[{cls.__name__}] must define .state_machine_name: str that points to a valid StateMachine') - - # @classproperty - # def final_q(cls) -> Q: - # """Get the filter for objects that are in a final state""" - # return Q(**{f'{cls.state_field_name}__in': cls.final_states}) - - # @classproperty - # def active_q(cls) -> Q: - # """Get the filter for objects that are actively processing right now""" - # return Q(**{cls.state_field_name: cls._state_to_str(cls.active_state)}) # e.g. Q(status='started') - - # @classproperty - # def stalled_q(cls) -> Q: - # """Get the filter for objects that are marked active but have timed out""" - # return cls.active_q & Q(retry_at__lte=timezone.now()) # e.g. Q(status='started') AND Q(<retry_at is in the past>) - - # @classproperty - # def future_q(cls) -> Q: - # """Get the filter for objects that have a retry_at in the future""" - # return Q(retry_at__gt=timezone.now()) - - # @classproperty - # def pending_q(cls) -> Q: - # """Get the filter for objects that are ready for processing.""" - # return ~(cls.active_q) & ~(cls.final_q) & ~(cls.future_q) - - # @classmethod - # def get_queue(cls) -> QuerySet: - # """ - # Get the sorted and filtered QuerySet of objects that are ready for processing. - # e.g. qs.exclude(status__in=('sealed', 'started'), retry_at__gt=timezone.now()).order_by('retry_at') - # """ - # return cls.objects.filter(cls.pending_q) class ModelWithStateMachine(BaseModelWithStateMachine): StatusChoices: ClassVar[Type[DefaultStatusChoices]] = DefaultStatusChoices - + status: models.CharField = BaseModelWithStateMachine.StatusField() retry_at: models.DateTimeField = BaseModelWithStateMachine.RetryAtField() - + state_machine_name: ClassVar[str] # e.g. 'core.statemachines.ArchiveResultMachine' state_field_name: ClassVar[str] = 'status' state_machine_attr: ClassVar[str] = 'sm' bind_events_as_methods: ClassVar[bool] = True - + active_state: ClassVar[str] = StatusChoices.STARTED retry_at_field_name: ClassVar[str] = 'retry_at' - + class Meta: abstract = True - - - - - -class EventDict(TypedDict, total=False): - name: str - - id: str | uuid.UUID - path: str - content: str - status: str - retry_at: datetime | None - url: str - seed_id: str | uuid.UUID - crawl_id: str | uuid.UUID - snapshot_id: str | uuid.UUID - process_id: str | uuid.UUID - extractor: str - error: str - on_success: dict | None - on_failure: dict | None - -class EventManager(models.Manager): - pass - -class EventQuerySet(models.QuerySet): - def get_next_unclaimed(self) -> 'Event | None': - return self.filter(claimed_at=None).order_by('deliver_at').first() - - def expired(self, older_than: int=60 * 10) -> QuerySet['Event']: - return self.filter(claimed_at__lt=timezone.now() - timedelta(seconds=older_than)) - - -class Event(models.Model): - id = models.UUIDField(primary_key=True, default=uuid.uuid4, null=False, editable=False, unique=True) - - # immutable fields - deliver_at = models.DateTimeField(default=timezone.now, null=False, editable=False, unique=True, db_index=True) - name = models.CharField(max_length=255, null=False, blank=False, db_index=True) - kwargs = models.JSONField(default=dict) - timeout = models.IntegerField(null=False, default=60) - parent = models.ForeignKey('Event', null=True, on_delete=models.SET_NULL, related_name='child_events') - emitted_by = models.ForeignKey(Process, null=False, on_delete=models.PROTECT, related_name='emitted_events') - on_success = models.JSONField(null=True) - on_failure = models.JSONField(null=True) - - # mutable fields - modified_at = models.DateTimeField(auto_now=True) - claimed_proc = models.ForeignKey(Process, null=True, on_delete=models.CASCADE, related_name='claimed_events') - claimed_at = models.DateTimeField(null=True) - finished_at = models.DateTimeField(null=True) - error = models.TextField(null=True) - - objects: EventManager = EventManager.from_queryset(EventQuerySet)() - - child_events: models.RelatedManager['Event'] - - @classmethod - def get_next_timestamp(cls): - """Get the next monotonically increasing timestamp for the next event.dispatch_at""" - latest_event = cls.objects.order_by('-deliver_at').first() - ts = timezone.now() - if latest_event: - assert ts > latest_event.deliver_at, f'Event.deliver_at is not monotonically increasing: {latest_event.deliver_at} > {ts}' - return ts - - @classmethod - def dispatch(cls, name: str | EventDict | None = None, event: EventDict | None = None, **event_init_kwargs) -> 'Event': - """ - Create a new Event and save it to the database. - - Can be called as either: - >>> Event.dispatch(name, {**kwargs}, **event_init_kwargs) - # OR - >>> Event.dispatch({name, **kwargs}, **event_init_kwargs) - """ - event_kwargs: EventDict = event or {} - if isinstance(name, dict): - event_kwargs.update(name) - assert isinstance(event_kwargs, dict), 'must be called as Event.dispatch(name, {**kwargs}) or Event.dispatch({name, **kwargs})' - - event_name: str = name if (isinstance(name, str) and name) else event_kwargs.pop('name') - - new_event = cls( - name=event_name, - kwargs=event_kwargs, - emitted_by=Process.current(), - **event_init_kwargs, - ) - new_event.save() - return new_event - - def clean(self, *args, **kwargs) -> None: - """Fill and validate all the event fields""" - - # check uuid and deliver_at are set - assert self.id, 'Event.id must be set to a valid v4 UUID' - if not self.deliver_at: - self.deliver_at = self.get_next_timestamp() - assert self.deliver_at and (datetime(2024, 12, 8, 12, 0, 0, tzinfo=timezone.utc) < self.deliver_at < datetime(2100, 12, 31, 23, 59, 0, tzinfo=timezone.utc)), ( - f'Event.deliver_at must be set to a valid UTC datetime (got Event.deliver_at = {self.deliver_at})') - - # if name is not set but it's found in the kwargs, move it out of the kwargs to the name field - if 'type' in self.kwargs and ((self.name == self.kwargs['type']) or not self.name): - self.name = self.kwargs.pop('type') - if 'name' in self.kwargs and ((self.name == self.kwargs['name']) or not self.name): - self.name = self.kwargs.pop('name') - - # check name is set and is a valid identifier - assert isinstance(self.name, str) and len(self.name) > 3, 'Event.name must be set to a non-empty string' - assert self.name.isidentifier(), f'Event.name must be a valid identifier (got Event.name = {self.name})' - assert self.name.isupper(), f'Event.name must be in uppercase (got Event.name = {self.name})' - - # check that kwargs keys and values are valid - for key, value in self.kwargs.items(): - assert isinstance(key, str), f'Event kwargs keys can only be strings (got Event.kwargs[{key}: {type(key).__name__}])' - assert key not in self._meta.get_fields(), f'Event.kwargs cannot contain "{key}" key (Event.kwargs[{key}] conflicts with with reserved attr Event.{key} = {getattr(self, key)})' - assert json.dumps(value, sort_keys=True), f'Event can only contain JSON serializable values (got Event.kwargs[{key}]: {type(value).__name__} = {value})' - - # validate on_success and on_failure are valid event dicts if set - if self.on_success: - assert isinstance(self.on_success, dict) and self.on_success.get('name', '!invalid').isidentifier(), f'Event.on_success must be a valid event dict (got {self.on_success})' - if self.on_failure: - assert isinstance(self.on_failure, dict) and self.on_failure.get('name', '!invalid').isidentifier(), f'Event.on_failure must be a valid event dict (got {self.on_failure})' - - # validate mutable fields like claimed_at, claimed_proc, finished_at are set correctly - if self.claimed_at: - assert self.claimed_proc, f'Event.claimed_at and Event.claimed_proc must be set together (only found Event.claimed_at = {self.claimed_at})' - if self.claimed_proc: - assert self.claimed_at, f'Event.claimed_at and Event.claimed_proc must be set together (only found Event.claimed_proc = {self.claimed_proc})' - if self.finished_at: - assert self.claimed_at, f'If Event.finished_at is set, Event.claimed_at and Event.claimed_proc must also be set (Event.claimed_proc = {self.claimed_proc} and Event.claimed_at = {self.claimed_at})' - - # validate error is a non-empty string or None - if isinstance(self.error, BaseException): - self.error = f'{type(self.error).__name__}: {self.error}' - if self.error: - assert isinstance(self.error, str) and str(self.error).strip(), f'Event.error must be a non-empty string (got Event.error: {type(self.error).__name__} = {self.error})' - else: - assert self.error is None, f'Event.error must be None or a non-empty string (got Event.error: {type(self.error).__name__} = {self.error})' - - - def save(self, *args, **kwargs): - self.clean() - return super().save(*args, **kwargs) - - def reset(self): - """Force-update an event to a pending/unclaimed state (without running any of its handlers or callbacks)""" - self.claimed_proc = None - self.claimed_at = None - self.finished_at = None - self.error = None - self.save() - - def abort(self): - """Force-update an event to a completed/failed state (without running any of its handlers or callbacks)""" - self.claimed_proc = Process.current() - self.claimed_at = timezone.now() - self.finished_at = timezone.now() - self.error = 'Aborted' - self.save() - - - def __repr__(self) -> str: - label = f'[{self.name} {self.kwargs}]' - if self.is_finished: - label += f' ✅' - elif self.claimed_proc: - label += f' 🏃' - return label - - def __str__(self) -> str: - return repr(self) - - @property - def type(self) -> str: - return self.name - - @property - def is_queued(self): - return not self.is_claimed and not self.is_finished - - @property - def is_claimed(self): - return self.claimed_at is not None - - @property - def is_expired(self): - if not self.claimed_at: - return False - - elapsed_time = timezone.now() - self.claimed_at - return elapsed_time > timedelta(seconds=self.timeout) - - @property - def is_processing(self): - return self.is_claimed and not self.is_finished - - @property - def is_finished(self): - return self.finished_at is not None - - @property - def is_failed(self): - return self.is_finished and bool(self.error) - - @property - def is_succeeded(self): - return self.is_finished and not bool(self.error) - - def __getattr__(self, key: str): - """ - Allow access to the event kwargs as attributes e.g. - Event(name='CRAWL_CREATE', kwargs={'some_key': 'some_val'}).some_key -> 'some_val' - """ - return self.kwargs.get(key) diff --git a/archivebox/workers/orchestrator.py b/archivebox/workers/orchestrator.py index d2cf2530..68a13628 100644 --- a/archivebox/workers/orchestrator.py +++ b/archivebox/workers/orchestrator.py @@ -1,206 +1,287 @@ +""" +Orchestrator for managing worker processes. + +The Orchestrator polls queues for each model type (Crawl, Snapshot, ArchiveResult) +and lazily spawns worker processes when there is work to be done. + +Architecture: + Orchestrator (main loop, polls queues) + ├── CrawlWorker subprocess(es) + ├── SnapshotWorker subprocess(es) + └── ArchiveResultWorker subprocess(es) + └── Each worker spawns task subprocesses via CLI + +Usage: + # Embedded in other commands (exits when done) + orchestrator = Orchestrator(exit_on_idle=True) + orchestrator.runloop() + + # Daemon mode (runs forever) + orchestrator = Orchestrator(exit_on_idle=False) + orchestrator.start() # fork and return + + # Or run via CLI + archivebox orchestrator [--daemon] +""" + __package__ = 'archivebox.workers' import os import time -import sys -import itertools -from typing import Dict, Type, Literal, TYPE_CHECKING -from django.utils.functional import classproperty +from typing import Type +from multiprocessing import Process + from django.utils import timezone -import multiprocessing - - - from rich import print -# from django.db.models import QuerySet - -from django.apps import apps - -if TYPE_CHECKING: - from .actor import ActorType - - -multiprocessing.set_start_method('fork', force=True) +from .worker import Worker, CrawlWorker, SnapshotWorker, ArchiveResultWorker +from .pid_utils import ( + write_pid_file, + remove_pid_file, + get_all_worker_pids, + cleanup_stale_pid_files, +) class Orchestrator: - pid: int - idle_count: int = 0 - actor_types: Dict[str, Type['ActorType']] = {} - mode: Literal['thread', 'process'] = 'process' - exit_on_idle: bool = True - max_concurrent_actors: int = 20 + """ + Manages worker processes by polling queues and spawning workers as needed. - def __init__(self, actor_types: Dict[str, Type['ActorType']] | None = None, mode: Literal['thread', 'process'] | None=None, exit_on_idle: bool=True, max_concurrent_actors: int=max_concurrent_actors): - self.actor_types = actor_types or self.actor_types or self.autodiscover_actor_types() - self.mode = mode or self.mode + The orchestrator: + 1. Polls each model queue (Crawl, Snapshot, ArchiveResult) + 2. If items exist and fewer than MAX_CONCURRENT workers are running, spawns workers + 3. Monitors worker health and cleans up stale PIDs + 4. Exits when all queues are empty (unless daemon mode) + """ + + WORKER_TYPES: list[Type[Worker]] = [CrawlWorker, SnapshotWorker, ArchiveResultWorker] + + # Configuration + POLL_INTERVAL: float = 1.0 + IDLE_TIMEOUT: int = 3 # Exit after N idle ticks (0 = never exit) + MAX_WORKERS_PER_TYPE: int = 4 # Max workers per model type + MAX_TOTAL_WORKERS: int = 12 # Max workers across all types + + def __init__(self, exit_on_idle: bool = True): self.exit_on_idle = exit_on_idle - self.max_concurrent_actors = max_concurrent_actors - + self.pid: int = os.getpid() + self.pid_file = None + self.idle_count: int = 0 + def __repr__(self) -> str: - label = 'tid' if self.mode == 'thread' else 'pid' - return f'[underline]{self.name}[/underline]\\[{label}={self.pid}]' - - def __str__(self) -> str: - return self.__repr__() - - @classproperty - def name(cls) -> str: - return cls.__name__ # type: ignore - - # def _fork_as_thread(self): - # self.thread = Thread(target=self.runloop) - # self.thread.start() - # assert self.thread.native_id is not None - # return self.thread.native_id - - def _fork_as_process(self): - self.process = multiprocessing.Process(target=self.runloop) - self.process.start() - assert self.process.pid is not None - return self.process.pid - - def start(self) -> int: - if self.mode == 'thread': - # return self._fork_as_thread() - raise NotImplementedError('Thread-based orchestrators are disabled for now to reduce codebase complexity') - elif self.mode == 'process': - return self._fork_as_process() - raise ValueError(f'Invalid orchestrator mode: {self.mode}') + return f'[underline]Orchestrator[/underline]\\[pid={self.pid}]' @classmethod - def autodiscover_actor_types(cls) -> Dict[str, Type['ActorType']]: - from archivebox.config.django import setup_django - setup_django() + def is_running(cls) -> bool: + """Check if an orchestrator is already running.""" + workers = get_all_worker_pids('orchestrator') + return len(workers) > 0 + + def on_startup(self) -> None: + """Called when orchestrator starts.""" + self.pid = os.getpid() + self.pid_file = write_pid_file('orchestrator', worker_id=0) + print(f'[green]👨‍✈️ {self} STARTED[/green]') - # returns a Dict of all discovered {actor_type_id: ActorType} across the codebase - # override this method in a subclass to customize the actor types that are used - # return {'Snapshot': SnapshotWorker, 'ArchiveResult_chrome': ChromeActorType, ...} - from crawls.statemachines import CrawlWorker - from core.statemachines import SnapshotWorker, ArchiveResultWorker - return { - 'CrawlWorker': CrawlWorker, - 'SnapshotWorker': SnapshotWorker, - 'ArchiveResultWorker': ArchiveResultWorker, - # look through all models and find all classes that inherit from ActorType - # actor_type.__name__: actor_type - # for actor_type in abx.pm.hook.get_all_ACTORS_TYPES().values() - } + # Clean up any stale PID files from previous runs + stale_count = cleanup_stale_pid_files() + if stale_count: + print(f'[yellow]👨‍✈️ {self} cleaned up {stale_count} stale PID files[/yellow]') - @classmethod - def get_orphaned_objects(cls, all_queues) -> list: - # returns a list of objects that are in the queues of all actor types but not in the queues of any other actor types - all_queued_ids = itertools.chain(*[queue.values('id', flat=True) for queue in all_queues.values()]) - orphaned_objects = [] - for model in apps.get_models(): - if hasattr(model, 'retry_at'): - orphaned_objects.extend(model.objects.filter(retry_at__lt=timezone.now()).exclude(id__in=all_queued_ids)) - return orphaned_objects - - @classmethod - def has_future_objects(cls, all_queues) -> bool: - # returns a list of objects that are in the queues of all actor types but not in the queues of any other actor types - - return any( - queue.filter(retry_at__gte=timezone.now()).exists() - for queue in all_queues.values() - ) - - def on_startup(self): - if self.mode == 'thread': - # self.pid = get_native_id() - print(f'[green]👨‍✈️ {self}.on_startup() STARTUP (THREAD)[/green]') - raise NotImplementedError('Thread-based orchestrators are disabled for now to reduce codebase complexity') - elif self.mode == 'process': - self.pid = os.getpid() - print(f'[green]👨‍✈️ {self}.on_startup() STARTUP (PROCESS)[/green]') - # abx.pm.hook.on_orchestrator_startup(self) - - def on_shutdown(self, err: BaseException | None = None): - print(f'[grey53]👨‍✈️ {self}.on_shutdown() SHUTTING DOWN[/grey53]', err or '[green](gracefully)[/green]') - # abx.pm.hook.on_orchestrator_shutdown(self) + def on_shutdown(self, error: BaseException | None = None) -> None: + """Called when orchestrator shuts down.""" + if self.pid_file: + remove_pid_file(self.pid_file) - def on_tick_started(self, all_queues): - # total_pending = sum(queue.count() for queue in all_queues.values()) - # if total_pending: - # print(f'👨‍✈️ {self}.on_tick_started()', f'total_pending={total_pending}') - # abx.pm.hook.on_orchestrator_tick_started(self, actor_types, all_queues) - pass + if error and not isinstance(error, KeyboardInterrupt): + print(f'[red]👨‍✈️ {self} SHUTDOWN with error:[/red] {type(error).__name__}: {error}') + else: + print(f'[grey53]👨‍✈️ {self} SHUTDOWN[/grey53]') - def on_tick_finished(self, all_queues, all_existing_actors, all_spawned_actors): - # if all_spawned_actors: - # total_queue_length = sum(queue.count() for queue in all_queues.values()) - # print(f'[grey53]👨‍✈️ {self}.on_tick_finished() queue={total_queue_length} existing_actors={len(all_existing_actors)} spawned_actors={len(all_spawned_actors)}[/grey53]') - # abx.pm.hook.on_orchestrator_tick_finished(self, actor_types, all_queues) - pass - - def on_idle(self, all_queues): - # print(f'👨‍✈️ {self}.on_idle()', f'idle_count={self.idle_count}') - print('.', end='', flush=True, file=sys.stderr) - # abx.pm.hook.on_orchestrator_idle(self) - # check for orphaned objects left behind - if self.idle_count == 60: - orphaned_objects = self.get_orphaned_objects(all_queues) - if orphaned_objects: - print('[red]👨‍✈️ WARNING: some objects may not be processed, no actor has claimed them after 30s:[/red]', orphaned_objects) - if self.idle_count > 3 and self.exit_on_idle and not self.has_future_objects(all_queues): - raise KeyboardInterrupt('✅ All tasks completed, exiting') - - def runloop(self): - from archivebox.config.django import setup_django - setup_django() + def get_total_worker_count(self) -> int: + """Get total count of running workers across all types.""" + cleanup_stale_pid_files() + return sum(len(W.get_running_workers()) for W in self.WORKER_TYPES) + + def should_spawn_worker(self, WorkerClass: Type[Worker], queue_count: int) -> bool: + """Determine if we should spawn a new worker of the given type.""" + if queue_count == 0: + return False + # Check per-type limit + running_workers = WorkerClass.get_running_workers() + if len(running_workers) >= self.MAX_WORKERS_PER_TYPE: + return False + + # Check total limit + if self.get_total_worker_count() >= self.MAX_TOTAL_WORKERS: + return False + + # Check if we already have enough workers for the queue size + # Spawn more gradually - don't flood with workers + if len(running_workers) > 0 and queue_count <= len(running_workers) * WorkerClass.MAX_CONCURRENT_TASKS: + return False + + return True + + def spawn_worker(self, WorkerClass: Type[Worker]) -> int | None: + """Spawn a new worker process. Returns PID or None if spawn failed.""" + try: + pid = WorkerClass.start(daemon=False) + print(f'[blue]👨‍✈️ {self} spawned {WorkerClass.name} worker[/blue] pid={pid}') + return pid + except Exception as e: + print(f'[red]👨‍✈️ {self} failed to spawn {WorkerClass.name} worker:[/red] {e}') + return None + + def check_queues_and_spawn_workers(self) -> dict[str, int]: + """ + Check all queues and spawn workers as needed. + Returns dict of queue sizes by worker type. + """ + queue_sizes = {} + + for WorkerClass in self.WORKER_TYPES: + # Get queue for this worker type + # Need to instantiate worker to get queue (for model access) + worker = WorkerClass(worker_id=-1) # temp instance just for queue access + queue = worker.get_queue() + queue_count = queue.count() + queue_sizes[WorkerClass.name] = queue_count + + # Spawn worker if needed + if self.should_spawn_worker(WorkerClass, queue_count): + self.spawn_worker(WorkerClass) + + return queue_sizes + + def has_pending_work(self, queue_sizes: dict[str, int]) -> bool: + """Check if any queue has pending work.""" + return any(count > 0 for count in queue_sizes.values()) + + def has_running_workers(self) -> bool: + """Check if any workers are still running.""" + return self.get_total_worker_count() > 0 + + def has_future_work(self) -> bool: + """Check if there's work scheduled for the future (retry_at > now).""" + for WorkerClass in self.WORKER_TYPES: + worker = WorkerClass(worker_id=-1) + Model = worker.get_model() + # Check for items not in final state with future retry_at + future_count = Model.objects.filter( + retry_at__gt=timezone.now() + ).exclude( + status__in=Model.FINAL_STATES + ).count() + if future_count > 0: + return True + return False + + def on_tick(self, queue_sizes: dict[str, int]) -> None: + """Called each orchestrator tick. Override for custom behavior.""" + total_queued = sum(queue_sizes.values()) + total_workers = self.get_total_worker_count() + + if total_queued > 0 or total_workers > 0: + # Build status line + status_parts = [] + for WorkerClass in self.WORKER_TYPES: + name = WorkerClass.name + queued = queue_sizes.get(name, 0) + workers = len(WorkerClass.get_running_workers()) + if queued > 0 or workers > 0: + status_parts.append(f'{name}={queued}q/{workers}w') + + if status_parts: + print(f'[grey53]👨‍✈️ {self} tick:[/grey53] {" ".join(status_parts)}') + + def on_idle(self) -> None: + """Called when orchestrator is idle (no work, no workers).""" + if self.idle_count == 1: + print(f'[grey53]👨‍✈️ {self} idle, waiting for work...[/grey53]') + + def should_exit(self, queue_sizes: dict[str, int]) -> bool: + """Determine if orchestrator should exit.""" + if not self.exit_on_idle: + return False + + if self.IDLE_TIMEOUT == 0: + return False + + # Don't exit if there's pending or future work + if self.has_pending_work(queue_sizes): + return False + + if self.has_running_workers(): + return False + + if self.has_future_work(): + return False + + # Exit after idle timeout + return self.idle_count >= self.IDLE_TIMEOUT + + def runloop(self) -> None: + """Main orchestrator loop.""" self.on_startup() + try: while True: - all_queues = { - actor_type: actor_type.get_queue() - for actor_type in self.actor_types.values() - } - if not all_queues: - raise Exception('Failed to find any actor_types to process') - - self.on_tick_started(all_queues) - - all_existing_actors = [] - all_spawned_actors = [] - - for actor_type, queue in all_queues.items(): - if not queue.exists(): - continue - - next_obj = queue.first() - print() - print(f'🏃‍♂️ {self}.runloop() {actor_type.__name__.ljust(20)} queue={str(queue.count()).ljust(3)} next={next_obj.id if next_obj else "None"} {next_obj.status if next_obj else "None"} {(timezone.now() - next_obj.retry_at).total_seconds() if next_obj and next_obj.retry_at else "None"}') + # Check queues and spawn workers + queue_sizes = self.check_queues_and_spawn_workers() + + # Track idle state + if self.has_pending_work(queue_sizes) or self.has_running_workers(): self.idle_count = 0 - try: - existing_actors = actor_type.get_running_actors() - all_existing_actors.extend(existing_actors) - actors_to_spawn = actor_type.get_actors_to_spawn(queue, existing_actors) - can_spawn_num_remaining = self.max_concurrent_actors - len(all_existing_actors) # set max_concurrent_actors=1 to disable multitasking - for launch_kwargs in actors_to_spawn[:can_spawn_num_remaining]: - new_actor_pid = actor_type.start(mode='process', **launch_kwargs) - all_spawned_actors.append(new_actor_pid) - except Exception as err: - print(f'🏃‍♂️ ERROR: {self} Failed to get {actor_type} queue & running actors', err) - except BaseException: - raise - - if not any(queue.exists() for queue in all_queues.values()): - self.on_idle(all_queues) - self.idle_count += 1 - time.sleep(0.5) + self.on_tick(queue_sizes) else: - self.idle_count = 0 - - self.on_tick_finished(all_queues, all_existing_actors, all_spawned_actors) - time.sleep(1) - - except BaseException as err: - if isinstance(err, KeyboardInterrupt): - print() - else: - print(f'\n[red]🏃‍♂️ {self}.runloop() FATAL:[/red]', err.__class__.__name__, err) - self.on_shutdown(err=err) + self.idle_count += 1 + self.on_idle() + + # Check if we should exit + if self.should_exit(queue_sizes): + print(f'[green]👨‍✈️ {self} all work complete, exiting[/green]') + break + + time.sleep(self.POLL_INTERVAL) + + except KeyboardInterrupt: + print() # Newline after ^C + except BaseException as e: + self.on_shutdown(error=e) + raise + else: + self.on_shutdown() + + def start(self) -> int: + """ + Fork orchestrator as a background process. + Returns the PID of the new process. + """ + def run_orchestrator(): + from archivebox.config.django import setup_django + setup_django() + self.runloop() + + proc = Process(target=run_orchestrator, name='orchestrator') + proc.start() + + assert proc.pid is not None + print(f'[green]👨‍✈️ Orchestrator started in background[/green] pid={proc.pid}') + return proc.pid + + @classmethod + def get_or_start(cls, exit_on_idle: bool = True) -> 'Orchestrator': + """ + Get running orchestrator or start a new one. + Used by commands like 'add' to ensure orchestrator is running. + """ + if cls.is_running(): + print('[grey53]👨‍✈️ Orchestrator already running[/grey53]') + # Return a placeholder - actual orchestrator is in another process + return cls(exit_on_idle=exit_on_idle) + + orchestrator = cls(exit_on_idle=exit_on_idle) + return orchestrator diff --git a/archivebox/workers/pid_utils.py b/archivebox/workers/pid_utils.py new file mode 100644 index 00000000..020fce70 --- /dev/null +++ b/archivebox/workers/pid_utils.py @@ -0,0 +1,191 @@ +""" +PID file utilities for tracking worker and orchestrator processes. + +PID files are stored in data/tmp/workers/ and contain: +- Line 1: PID +- Line 2: Worker type (orchestrator, crawl, snapshot, archiveresult) +- Line 3: Extractor filter (optional, for archiveresult workers) +- Line 4: Started at ISO timestamp +""" + +__package__ = 'archivebox.workers' + +import os +import signal +from pathlib import Path +from datetime import datetime, timezone + +from django.conf import settings + + +def get_pid_dir() -> Path: + """Get the directory for PID files, creating it if needed.""" + pid_dir = Path(settings.DATA_DIR) / 'tmp' / 'workers' + pid_dir.mkdir(parents=True, exist_ok=True) + return pid_dir + + +def write_pid_file(worker_type: str, worker_id: int = 0, extractor: str | None = None) -> Path: + """ + Write a PID file for the current process. + Returns the path to the PID file. + """ + pid_dir = get_pid_dir() + + if worker_type == 'orchestrator': + pid_file = pid_dir / 'orchestrator.pid' + else: + pid_file = pid_dir / f'{worker_type}_worker_{worker_id}.pid' + + content = f"{os.getpid()}\n{worker_type}\n{extractor or ''}\n{datetime.now(timezone.utc).isoformat()}\n" + pid_file.write_text(content) + + return pid_file + + +def read_pid_file(path: Path) -> dict | None: + """ + Read and parse a PID file. + Returns dict with pid, worker_type, extractor, started_at or None if invalid. + """ + try: + if not path.exists(): + return None + + lines = path.read_text().strip().split('\n') + if len(lines) < 4: + return None + + return { + 'pid': int(lines[0]), + 'worker_type': lines[1], + 'extractor': lines[2] or None, + 'started_at': datetime.fromisoformat(lines[3]), + 'pid_file': path, + } + except (ValueError, IndexError, OSError): + return None + + +def remove_pid_file(path: Path) -> None: + """Remove a PID file if it exists.""" + try: + path.unlink(missing_ok=True) + except OSError: + pass + + +def is_process_alive(pid: int) -> bool: + """Check if a process with the given PID is still running.""" + try: + os.kill(pid, 0) # Signal 0 doesn't kill, just checks + return True + except (OSError, ProcessLookupError): + return False + + +def get_all_pid_files() -> list[Path]: + """Get all PID files in the workers directory.""" + pid_dir = get_pid_dir() + return list(pid_dir.glob('*.pid')) + + +def get_all_worker_pids(worker_type: str | None = None) -> list[dict]: + """ + Get info about all running workers. + Optionally filter by worker_type. + """ + workers = [] + + for pid_file in get_all_pid_files(): + info = read_pid_file(pid_file) + if info is None: + continue + + # Skip if process is dead + if not is_process_alive(info['pid']): + continue + + # Filter by type if specified + if worker_type and info['worker_type'] != worker_type: + continue + + workers.append(info) + + return workers + + +def cleanup_stale_pid_files() -> int: + """ + Remove PID files for processes that are no longer running. + Returns the number of stale files removed. + """ + removed = 0 + + for pid_file in get_all_pid_files(): + info = read_pid_file(pid_file) + if info is None: + # Invalid PID file, remove it + remove_pid_file(pid_file) + removed += 1 + continue + + if not is_process_alive(info['pid']): + remove_pid_file(pid_file) + removed += 1 + + return removed + + +def get_running_worker_count(worker_type: str) -> int: + """Get the count of running workers of a specific type.""" + return len(get_all_worker_pids(worker_type)) + + +def get_next_worker_id(worker_type: str) -> int: + """Get the next available worker ID for a given type.""" + existing_ids = set() + + for pid_file in get_all_pid_files(): + # Parse worker ID from filename like "snapshot_worker_3.pid" + name = pid_file.stem + if name.startswith(f'{worker_type}_worker_'): + try: + worker_id = int(name.split('_')[-1]) + existing_ids.add(worker_id) + except ValueError: + continue + + # Find the lowest unused ID + next_id = 0 + while next_id in existing_ids: + next_id += 1 + + return next_id + + +def stop_worker(pid: int, graceful: bool = True) -> bool: + """ + Stop a worker process. + If graceful=True, sends SIGTERM first, then SIGKILL after timeout. + Returns True if process was stopped. + """ + if not is_process_alive(pid): + return True + + try: + if graceful: + os.kill(pid, signal.SIGTERM) + # Give it a moment to shut down + import time + for _ in range(10): # Wait up to 1 second + time.sleep(0.1) + if not is_process_alive(pid): + return True + # Force kill if still running + os.kill(pid, signal.SIGKILL) + else: + os.kill(pid, signal.SIGKILL) + return True + except (OSError, ProcessLookupError): + return True # Process already dead diff --git a/archivebox/workers/semaphores.py b/archivebox/workers/semaphores.py deleted file mode 100644 index ed583893..00000000 --- a/archivebox/workers/semaphores.py +++ /dev/null @@ -1,103 +0,0 @@ -# import uuid -# from functools import wraps -# from django.db import connection, transaction -# from django.utils import timezone -# from huey.exceptions import TaskLockedException - -# from archivebox.config import CONSTANTS - -# class SqliteSemaphore: -# def __init__(self, db_path, table_name, name, value=1, timeout=None): -# self.db_path = db_path -# self.table_name = table_name -# self.name = name -# self.value = value -# self.timeout = timeout or 86400 # Set a max age for lock holders - -# # Ensure the table exists -# with connection.cursor() as cursor: -# cursor.execute(f""" -# CREATE TABLE IF NOT EXISTS {self.table_name} ( -# id TEXT PRIMARY KEY, -# name TEXT, -# timestamp DATETIME -# ) -# """) - -# def acquire(self, name=None): -# name = name or str(uuid.uuid4()) -# now = timezone.now() -# expiration = now - timezone.timedelta(seconds=self.timeout) - -# with transaction.atomic(): -# # Remove expired locks -# with connection.cursor() as cursor: -# cursor.execute(f""" -# DELETE FROM {self.table_name} -# WHERE name = %s AND timestamp < %s -# """, [self.name, expiration]) - -# # Try to acquire the lock -# with connection.cursor() as cursor: -# cursor.execute(f""" -# INSERT INTO {self.table_name} (id, name, timestamp) -# SELECT %s, %s, %s -# WHERE ( -# SELECT COUNT(*) FROM {self.table_name} -# WHERE name = %s -# ) < %s -# """, [name, self.name, now, self.name, self.value]) - -# if cursor.rowcount > 0: -# return name - -# # If we couldn't acquire the lock, remove our attempted entry -# with connection.cursor() as cursor: -# cursor.execute(f""" -# DELETE FROM {self.table_name} -# WHERE id = %s AND name = %s -# """, [name, self.name]) - -# return None - -# def release(self, name): -# with connection.cursor() as cursor: -# cursor.execute(f""" -# DELETE FROM {self.table_name} -# WHERE id = %s AND name = %s -# """, [name, self.name]) -# return cursor.rowcount > 0 - - -# LOCKS_DB_PATH = CONSTANTS.DATABASE_FILE.parent / 'locks.sqlite3' - - -# def lock_task_semaphore(db_path, table_name, lock_name, value=1, timeout=None): -# """ -# Lock which can be acquired multiple times (default = 1). - -# NOTE: no provisions are made for blocking, waiting, or notifying. This is -# just a lock which can be acquired a configurable number of times. - -# Example: - -# # Allow up to 3 workers to run this task concurrently. If the task is -# # locked, retry up to 2 times with a delay of 60s. -# @huey.task(retries=2, retry_delay=60) -# @lock_task_semaphore('path/to/db.sqlite3', 'semaphore_locks', 'my-lock', 3) -# def my_task(): -# ... -# """ -# sem = SqliteSemaphore(db_path, table_name, lock_name, value, timeout) -# def decorator(fn): -# @wraps(fn) -# def inner(*args, **kwargs): -# tid = sem.acquire() -# if tid is None: -# raise TaskLockedException(f'unable to acquire lock {lock_name}') -# try: -# return fn(*args, **kwargs) -# finally: -# sem.release(tid) -# return inner -# return decorator diff --git a/archivebox/workers/tasks.py b/archivebox/workers/tasks.py index b81ee990..9bf2f200 100644 --- a/archivebox/workers/tasks.py +++ b/archivebox/workers/tasks.py @@ -63,61 +63,68 @@ def bg_add(add_kwargs, task=None, parent_task_id=None): @task(queue="commands", context=True) -def bg_archive_links(args, kwargs=None, task=None, parent_task_id=None): +def bg_archive_snapshots(snapshots, kwargs=None, task=None, parent_task_id=None): + """ + Queue multiple snapshots for archiving via the state machine system. + + This sets snapshots to 'queued' status so the orchestrator workers pick them up. + The actual archiving happens through ArchiveResult.run(). + """ get_or_create_supervisord_process(daemonize=False) - - from ..extractors import archive_links - + + from django.utils import timezone + from core.models import Snapshot + if task and parent_task_id: TaskModel.objects.set_parent_task(main_task_id=parent_task_id, sub_task_id=task.id) - assert args and args[0] + assert snapshots kwargs = kwargs or {} - - rough_count = len(args[0]) - - process_info = ProcessInfo(task, desc="archive_links", parent_task_id=parent_task_id, total=rough_count) - - result = archive_links(*args, **kwargs) - process_info.update(n=rough_count) - return result + rough_count = len(snapshots) if hasattr(snapshots, '__len__') else snapshots.count() + process_info = ProcessInfo(task, desc="archive_snapshots", parent_task_id=parent_task_id, total=rough_count) -@task(queue="commands", context=True) -def bg_archive_link(args, kwargs=None,task=None, parent_task_id=None): - get_or_create_supervisord_process(daemonize=False) - - from ..extractors import archive_link - - if task and parent_task_id: - TaskModel.objects.set_parent_task(main_task_id=parent_task_id, sub_task_id=task.id) + # Queue snapshots by setting status to queued with immediate retry_at + queued_count = 0 + for snapshot in snapshots: + if hasattr(snapshot, 'id'): + # Update snapshot to queued state so workers pick it up + Snapshot.objects.filter(id=snapshot.id).update( + status=Snapshot.StatusChoices.QUEUED, + retry_at=timezone.now(), + ) + queued_count += 1 - assert args and args[0] - kwargs = kwargs or {} - - rough_count = len(args[0]) - - process_info = ProcessInfo(task, desc="archive_link", parent_task_id=parent_task_id, total=rough_count) - - result = archive_link(*args, **kwargs) - process_info.update(n=rough_count) - return result + process_info.update(n=queued_count) + return queued_count @task(queue="commands", context=True) def bg_archive_snapshot(snapshot, overwrite=False, methods=None, task=None, parent_task_id=None): - # get_or_create_supervisord_process(daemonize=False) + """ + Queue a single snapshot for archiving via the state machine system. + + This sets the snapshot to 'queued' status so the orchestrator workers pick it up. + The actual archiving happens through ArchiveResult.run(). + """ + get_or_create_supervisord_process(daemonize=False) + + from django.utils import timezone + from core.models import Snapshot - from ..extractors import archive_link - if task and parent_task_id: TaskModel.objects.set_parent_task(main_task_id=parent_task_id, sub_task_id=task.id) - process_info = ProcessInfo(task, desc="archive_link", parent_task_id=parent_task_id, total=1) - - link = snapshot.as_link_with_details() - - result = archive_link(link, overwrite=overwrite, methods=methods) - process_info.update(n=1) - return result + process_info = ProcessInfo(task, desc="archive_snapshot", parent_task_id=parent_task_id, total=1) + + # Queue the snapshot by setting status to queued + if hasattr(snapshot, 'id'): + Snapshot.objects.filter(id=snapshot.id).update( + status=Snapshot.StatusChoices.QUEUED, + retry_at=timezone.now(), + ) + process_info.update(n=1) + return 1 + + return 0 diff --git a/archivebox/workers/templates/jobs_dashboard.html b/archivebox/workers/templates/jobs_dashboard.html index 36cb20cd..a5aff5f8 100644 --- a/archivebox/workers/templates/jobs_dashboard.html +++ b/archivebox/workers/templates/jobs_dashboard.html @@ -115,7 +115,7 @@ const jobElement = document.createElement('div'); jobElement.className = 'job-item'; jobElement.innerHTML = ` - <p><a href="/api/v1/core/any/${job.abid}?api_key={{api_token|default:'NONE PROVIDED BY VIEW'}}"><code>${job.abid}</code></a></p> + <p><a href="/api/v1/core/any/${job.id}?api_key={{api_token|default:'NONE PROVIDED BY VIEW'}}"><code>${job.id}</code></a></p> <p> <span class="badge badge-${job.status}">${job.status}</span> <span class="date">♻️ ${formatDate(job.retry_at)}</span> diff --git a/archivebox/workers/tests.py b/archivebox/workers/tests.py deleted file mode 100644 index fd9567b5..00000000 --- a/archivebox/workers/tests.py +++ /dev/null @@ -1,25 +0,0 @@ -from django.test import TestCase - -# Create your tests here. - - -class CrawlActorTest(TestCase): - - def test_crawl_creation(self): - seed = Seed.objects.create(uri='https://example.com') - Event.dispatch('CRAWL_CREATE', {'seed_id': seed.id}) - - crawl_actor = CrawlActor() - - output_events = list(crawl_actor.process_next_event()) - - assert len(output_events) == 1 - assert output_events[0].get('name', 'unset') == 'FS_WRITE' - assert output_events[0].get('path') == '/tmp/test_crawl/index.json' - - output_events = list(crawl_actor.process_next_event()) - assert len(output_events) == 1 - assert output_events[0].get('name', 'unset') == 'CRAWL_CREATED' - - assert Crawl.objects.filter(seed_id=seed.id).exists(), 'Crawl was not created' - diff --git a/archivebox/workers/worker.py b/archivebox/workers/worker.py index 30ddc099..88689c72 100644 --- a/archivebox/workers/worker.py +++ b/archivebox/workers/worker.py @@ -1,457 +1,330 @@ +""" +Worker classes for processing queue items. + +Workers poll the database for items to process, claim them atomically, +and run the state machine tick() to process each item. + +Architecture: + Orchestrator (spawns workers) + └── Worker (claims items from queue, processes them directly) +""" + __package__ = 'archivebox.workers' import os -import sys import time -import uuid -import json - -from typing import ClassVar, Iterable, Type +import traceback +from typing import ClassVar, Any +from datetime import timedelta from pathlib import Path +from multiprocessing import Process, cpu_count + +from django.db.models import QuerySet +from django.utils import timezone +from django.conf import settings from rich import print -from django.db import transaction -from django.db.models import QuerySet -from django.utils import timezone -from django.utils.functional import classproperty # type: ignore - -from crawls.models import Crawl -from core.models import Snapshot, ArchiveResult - -from workers.models import Event, Process, EventDict +from .pid_utils import ( + write_pid_file, + remove_pid_file, + get_all_worker_pids, + get_next_worker_id, + cleanup_stale_pid_files, +) -class WorkerType: - # static class attributes - name: ClassVar[str] # e.g. 'log' or 'filesystem' or 'crawl' or 'snapshot' or 'archiveresult' etc. - - listens_to: ClassVar[str] # e.g. 'LOG_' or 'FS_' or 'CRAWL_' or 'SNAPSHOT_' or 'ARCHIVERESULT_' etc. - outputs: ClassVar[list[str]] # e.g. ['LOG_', 'FS_', 'CRAWL_', 'SNAPSHOT_', 'ARCHIVERESULT_'] etc. - - poll_interval: ClassVar[int] = 1 # how long to wait before polling for new events - - @classproperty - def event_queue(cls) -> QuerySet[Event]: - return Event.objects.filter(name__startswith=cls.listens_to) +CPU_COUNT = cpu_count() - @classmethod - def fork(cls, wait_for_first_event=False, exit_on_idle=True) -> Process: - cmd = ['archivebox', 'worker', cls.name] - if exit_on_idle: - cmd.append('--exit-on-idle') - if wait_for_first_event: - cmd.append('--wait-for-first-event') - return Process.create_and_fork(cmd=cmd, actor_type=cls.name) +# Registry of worker types by name (defined at bottom, referenced here for _run_worker) +WORKER_TYPES: dict[str, type['Worker']] = {} - @classproperty - def processes(cls) -> QuerySet[Process]: - return Process.objects.filter(actor_type=cls.name) - @classmethod - def run(cls, wait_for_first_event=False, exit_on_idle=True): +def _run_worker(worker_class_name: str, worker_id: int, daemon: bool, **kwargs): + """ + Module-level function to run a worker. Must be at module level for pickling. + """ + from archivebox.config.django import setup_django + setup_django() - if wait_for_first_event: - event = cls.event_queue.get_next_unclaimed() - while not event: - time.sleep(cls.poll_interval) - event = cls.event_queue.get_next_unclaimed() + # Get worker class by name to avoid pickling class objects + worker_cls = WORKER_TYPES[worker_class_name] + worker = worker_cls(worker_id=worker_id, daemon=daemon, **kwargs) + worker.runloop() - while True: - output_events = list(cls.process_next_event()) or list(cls.process_idle_tick()) # process next event, or tick if idle - yield from output_events - if not output_events: - if exit_on_idle: - break - else: - time.sleep(cls.poll_interval) - @classmethod - def process_next_event(cls) -> Iterable[EventDict]: - event = cls.event_queue.get_next_unclaimed() - output_events = [] - - if not event: - return [] - - cls.mark_event_claimed(event) - print(f'{cls.__name__}[{Process.current().pid}] {event}', file=sys.stderr) - try: - for output_event in cls.receive(event): - output_events.append(output_event) - yield output_event - cls.mark_event_succeeded(event, output_events=output_events) - except BaseException as e: - cls.mark_event_failed(event, output_events=output_events, error=e) +class Worker: + """ + Base worker class that polls a queue and processes items directly. - @classmethod - def process_idle_tick(cls) -> Iterable[EventDict]: - # reset the idle event to be claimed by the current process - event, _created = Event.objects.update_or_create( - name=f'{cls.listens_to}IDLE', - emitted_by=Process.current(), - defaults={ - 'deliver_at': timezone.now(), - 'claimed_proc': None, - 'claimed_at': None, - 'finished_at': None, - 'error': None, - 'parent': None, - }, + Each item is processed by calling its state machine tick() method. + Workers exit when idle for too long (unless daemon mode). + """ + + name: ClassVar[str] = 'worker' + + # Configuration (can be overridden by subclasses) + MAX_TICK_TIME: ClassVar[int] = 60 + POLL_INTERVAL: ClassVar[float] = 0.5 + IDLE_TIMEOUT: ClassVar[int] = 3 # Exit after N idle iterations (set to 0 to never exit) + + def __init__(self, worker_id: int = 0, daemon: bool = False, **kwargs: Any): + self.worker_id = worker_id + self.daemon = daemon + self.pid: int = os.getpid() + self.pid_file: Path | None = None + self.idle_count: int = 0 + + def __repr__(self) -> str: + return f'[underline]{self.__class__.__name__}[/underline]\\[id={self.worker_id}, pid={self.pid}]' + + def get_model(self): + """Get the Django model class. Subclasses must override this.""" + raise NotImplementedError("Subclasses must implement get_model()") + + def get_queue(self) -> QuerySet: + """Get the queue of objects ready for processing.""" + Model = self.get_model() + return Model.objects.filter( + retry_at__lte=timezone.now() + ).exclude( + status__in=Model.FINAL_STATES + ).order_by('retry_at') + + def claim_next(self): + """ + Atomically claim the next object from the queue. + Returns the claimed object or None if queue is empty or claim failed. + """ + Model = self.get_model() + obj = self.get_queue().first() + if obj is None: + return None + + # Atomic claim using optimistic locking on retry_at + claimed = Model.objects.filter( + pk=obj.pk, + retry_at=obj.retry_at, + ).update( + retry_at=timezone.now() + timedelta(seconds=self.MAX_TICK_TIME) ) - - # then process it like any other event - yield from cls.process_next_event() + + if claimed == 1: + obj.refresh_from_db() + return obj + + return None # Someone else claimed it + + def process_item(self, obj) -> bool: + """ + Process a single item by calling its state machine tick(). + Returns True on success, False on failure. + Subclasses can override for custom processing. + """ + try: + obj.sm.tick() + return True + except Exception as e: + print(f'[red]{self} error processing {obj.pk}:[/red] {e}') + traceback.print_exc() + return False + + def on_startup(self) -> None: + """Called when worker starts.""" + self.pid = os.getpid() + self.pid_file = write_pid_file(self.name, self.worker_id) + print(f'[green]{self} STARTED[/green] pid_file={self.pid_file}') + + def on_shutdown(self, error: BaseException | None = None) -> None: + """Called when worker shuts down.""" + # Remove PID file + if self.pid_file: + remove_pid_file(self.pid_file) + + if error and not isinstance(error, KeyboardInterrupt): + print(f'[red]{self} SHUTDOWN with error:[/red] {type(error).__name__}: {error}') + else: + print(f'[grey53]{self} SHUTDOWN[/grey53]') + + def should_exit(self) -> bool: + """Check if worker should exit due to idle timeout.""" + if self.daemon: + return False + + if self.IDLE_TIMEOUT == 0: + return False + + return self.idle_count >= self.IDLE_TIMEOUT + + def runloop(self) -> None: + """Main worker loop - polls queue, processes items.""" + self.on_startup() + + try: + while True: + # Try to claim and process an item + obj = self.claim_next() + + if obj is not None: + self.idle_count = 0 + print(f'[blue]{self} processing:[/blue] {obj.pk}') + + start_time = time.time() + success = self.process_item(obj) + elapsed = time.time() - start_time + + if success: + print(f'[green]{self} completed ({elapsed:.1f}s):[/green] {obj.pk}') + else: + print(f'[red]{self} failed ({elapsed:.1f}s):[/red] {obj.pk}') + else: + # No work available + self.idle_count += 1 + if self.idle_count == 1: + print(f'[grey53]{self} idle, waiting for work...[/grey53]') + + # Check if we should exit + if self.should_exit(): + print(f'[grey53]{self} idle timeout reached, exiting[/grey53]') + break + + time.sleep(self.POLL_INTERVAL) + + except KeyboardInterrupt: + pass + except BaseException as e: + self.on_shutdown(error=e) + raise + else: + self.on_shutdown() @classmethod - def receive(cls, event: Event) -> Iterable[EventDict]: - handler_method = getattr(cls, f'on_{event.name}', None) - if handler_method: - yield from handler_method(event) - else: - raise Exception(f'No handler method for event: {event.name}') + def start(cls, worker_id: int | None = None, daemon: bool = False, **kwargs: Any) -> int: + """ + Fork a new worker as a subprocess. + Returns the PID of the new process. + """ + if worker_id is None: + worker_id = get_next_worker_id(cls.name) - @staticmethod - def on_IDLE() -> Iterable[EventDict]: - return [] - - @staticmethod - def mark_event_claimed(event: Event): - proc = Process.current() - - with transaction.atomic(): - claimed = Event.objects.filter(id=event.id, claimed_proc=None, claimed_at=None).update(claimed_proc=proc, claimed_at=timezone.now()) - event.refresh_from_db() - if not claimed: - raise Exception(f'Event already claimed by another process: {event.claimed_proc}') - - print(f'{self}.mark_event_claimed(): Claimed {event} ⛏️') - - # process_updated = Process.objects.filter(id=proc.id, active_event=None).update(active_event=event) - # if not process_updated: - # raise Exception(f'Unable to update process.active_event: {proc}.active_event = {event}') + # Use module-level function for pickling compatibility + proc = Process( + target=_run_worker, + args=(cls.name, worker_id, daemon), + kwargs=kwargs, + name=f'{cls.name}_worker_{worker_id}', + ) + proc.start() - @staticmethod - def mark_event_succeeded(event: Event, output_events: Iterable[EventDict]): - event.refresh_from_db() - assert event.claimed_proc, f'Cannot mark event as succeeded if it is not claimed by a process: {event}' - assert (event.claimed_proc == Process.current()), f'Cannot mark event as succeeded if it claimed by a different process: {event}.claimed_proc = {event.claimed_proc}, current_process = {Process.current()}' - - with transaction.atomic(): - updated = Event.objects.filter(id=event.id, claimed_proc=event.claimed_proc, claimed_at=event.claimed_at, finished_at=None).update(finished_at=timezone.now()) - event.refresh_from_db() - if not updated: - raise Exception(f'Event {event} failed to mark as succeeded, it was modified by another process: {event.claimed_proc}') + assert proc.pid is not None + return proc.pid - # process_updated = Process.objects.filter(id=event.claimed_proc.id, active_event=event).update(active_event=None) - # if not process_updated: - # raise Exception(f'Unable to unset process.active_event: {event.claimed_proc}.active_event = {event}') + @classmethod + def get_running_workers(cls) -> list[dict]: + """Get info about all running workers of this type.""" + cleanup_stale_pid_files() + return get_all_worker_pids(cls.name) - # dispatch any output events - for output_event in output_events: - Event.dispatch(event=output_event, parent=event) - - # trigger any callback events - if event.on_success: - Event.dispatch(event=event.on_success, parent=event) - - @staticmethod - def mark_event_failed(event: Event, output_events: Iterable[EventDict]=(), error: BaseException | None = None): - event.refresh_from_db() - assert event.claimed_proc, f'Cannot mark event as failed if it is not claimed by a process: {event}' - assert (event.claimed_proc == Process.current()), f'Cannot mark event as failed if it claimed by a different process: {event}.claimed_proc = {event.claimed_proc}, current_process = {Process.current()}' - - with transaction.atomic(): - updated = Event.objects.filter(id=event.id, claimed_proc=event.claimed_proc, claimed_at=event.claimed_at, finished_at=None).update(finished_at=timezone.now(), error=str(error)) - event.refresh_from_db() - if not updated: - raise Exception(f'Event {event} failed to mark as failed, it was modified by another process: {event.claimed_proc}') - - # process_updated = Process.objects.filter(id=event.claimed_proc.id, active_event=event).update(active_event=None) - # if not process_updated: - # raise Exception(f'Unable to unset process.active_event: {event.claimed_proc}.active_event = {event}') - - - # add dedicated error event to the output events - if not event.name.endswith('_ERROR'): - output_events = [ - *output_events, - {'name': f'{event.name}_ERROR', 'msg': f'{type(error).__name__}: {error}'}, - ] - - # dispatch any output events - for output_event in output_events: - Event.dispatch(event=output_event, parent=event) - - # trigger any callback events - if event.on_failure: - Event.dispatch(event=event.on_failure, parent=event) + @classmethod + def get_worker_count(cls) -> int: + """Get count of running workers of this type.""" + return len(cls.get_running_workers()) +class CrawlWorker(Worker): + """Worker for processing Crawl objects.""" + + name: ClassVar[str] = 'crawl' + MAX_TICK_TIME: ClassVar[int] = 60 + + def get_model(self): + from crawls.models import Crawl + return Crawl -class OrchestratorWorker(WorkerType): - name = 'orchestrator' - listens_to = 'PROC_' - outputs = ['PROC_'] - - @staticmethod - def on_PROC_IDLE() -> Iterable[EventDict]: - # look through all Processes that are not yet launched and launch them - to_launch = Process.objects.filter(launched_at=None).order_by('created_at').first() - if not to_launch: - return [] - - yield {'name': 'PROC_LAUNCH', 'id': to_launch.id} - - @staticmethod - def on_PROC_LAUNCH(event: Event) -> Iterable[EventDict]: - process = Process.create_and_fork(**event.kwargs) - yield {'name': 'PROC_LAUNCHED', 'process_id': process.id} - - @staticmethod - def on_PROC_EXIT(event: Event) -> Iterable[EventDict]: - process = Process.objects.get(id=event.process_id) - process.kill() - yield {'name': 'PROC_KILLED', 'process_id': process.id} - - @staticmethod - def on_PROC_KILL(event: Event) -> Iterable[EventDict]: - process = Process.objects.get(id=event.process_id) - process.kill() - yield {'name': 'PROC_KILLED', 'process_id': process.id} +class SnapshotWorker(Worker): + """Worker for processing Snapshot objects.""" + + name: ClassVar[str] = 'snapshot' + MAX_TICK_TIME: ClassVar[int] = 60 + + def get_model(self): + from core.models import Snapshot + return Snapshot -class FileSystemWorker(WorkerType): - name = 'filesystem' - listens_to = 'FS_' - outputs = ['FS_'] +class ArchiveResultWorker(Worker): + """Worker for processing ArchiveResult objects.""" - @staticmethod - def on_FS_IDLE(event: Event) -> Iterable[EventDict]: - # check for tmp files that can be deleted - for tmp_file in Path('/tmp').glob('archivebox/*'): - yield {'name': 'FS_DELETE', 'path': str(tmp_file)} - - @staticmethod - def on_FS_WRITE(event: Event) -> Iterable[EventDict]: - with open(event.path, 'w') as f: - f.write(event.content) - yield {'name': 'FS_CHANGED', 'path': event.path} + name: ClassVar[str] = 'archiveresult' + MAX_TICK_TIME: ClassVar[int] = 120 - @staticmethod - def on_FS_APPEND(event: Event) -> Iterable[EventDict]: - with open(event.path, 'a') as f: - f.write(event.content) - yield {'name': 'FS_CHANGED', 'path': event.path} - - @staticmethod - def on_FS_DELETE(event: Event) -> Iterable[EventDict]: - os.remove(event.path) - yield {'name': 'FS_CHANGED', 'path': event.path} - - @staticmethod - def on_FS_RSYNC(event: Event) -> Iterable[EventDict]: - os.system(f'rsync -av {event.src} {event.dst}') - yield {'name': 'FS_CHANGED', 'path': event.dst} + def __init__(self, extractor: str | None = None, **kwargs: Any): + super().__init__(**kwargs) + self.extractor = extractor + + def get_model(self): + from core.models import ArchiveResult + return ArchiveResult + + def get_queue(self) -> QuerySet: + """Get queue of ArchiveResults ready for processing.""" + from django.db.models import Exists, OuterRef + from core.models import ArchiveResult + + qs = super().get_queue() + + if self.extractor: + qs = qs.filter(extractor=self.extractor) + + # Exclude ArchiveResults whose Snapshot already has one in progress + in_progress = ArchiveResult.objects.filter( + snapshot_id=OuterRef('snapshot_id'), + status=ArchiveResult.StatusChoices.STARTED, + ) + qs = qs.exclude(Exists(in_progress)) + + return qs + + def process_item(self, obj) -> bool: + """Process an ArchiveResult by running its extractor.""" + try: + obj.sm.tick() + return True + except Exception as e: + print(f'[red]{self} error processing {obj.pk}:[/red] {e}') + traceback.print_exc() + return False + + @classmethod + def start(cls, worker_id: int | None = None, daemon: bool = False, extractor: str | None = None, **kwargs: Any) -> int: + """Fork a new worker as subprocess with optional extractor filter.""" + if worker_id is None: + worker_id = get_next_worker_id(cls.name) + + # Use module-level function for pickling compatibility + proc = Process( + target=_run_worker, + args=(cls.name, worker_id, daemon), + kwargs={'extractor': extractor, **kwargs}, + name=f'{cls.name}_worker_{worker_id}', + ) + proc.start() + + assert proc.pid is not None + return proc.pid -class CrawlWorker(WorkerType): - name = 'crawl' - listens_to = 'CRAWL_' - outputs = ['CRAWL_', 'FS_', 'SNAPSHOT_'] - - @staticmethod - def on_CRAWL_IDLE(event: Event) -> Iterable[EventDict]: - # check for any stale crawls that can be started or sealed - stale_crawl = Crawl.objects.filter(retry_at__lt=timezone.now()).first() - if not stale_crawl: - return [] - - if stale_crawl.can_start(): - yield {'name': 'CRAWL_START', 'id': stale_crawl.id} - - elif stale_crawl.can_seal(): - yield {'name': 'CRAWL_SEAL', 'id': stale_crawl.id} - - @staticmethod - def on_CRAWL_CREATE(event: Event) -> Iterable[EventDict]: - crawl, created = Crawl.objects.get_or_create(id=event.id, defaults=event) - if created: - yield {'name': 'CRAWL_UPDATED', 'crawl_id': crawl.id} - - @staticmethod - def on_CRAWL_UPDATE(event: Event) -> Iterable[EventDict]: - crawl = Crawl.objects.get(id=event.pop('crawl_id')) - diff = { - key: val - for key, val in event.items() - if getattr(crawl, key) != val - } - if diff: - crawl.update(**diff) - yield {'name': 'CRAWL_UPDATED', 'crawl_id': crawl.id} - - @staticmethod - def on_CRAWL_UPDATED(event: Event) -> Iterable[EventDict]: - crawl = Crawl.objects.get(id=event.crawl_id) - yield {'name': 'FS_WRITE_SYMLINKS', 'path': crawl.OUTPUT_DIR, 'symlinks': crawl.output_dir_symlinks} - - - @staticmethod - def on_CRAWL_SEAL(event: Event) -> Iterable[EventDict]: - crawl = Crawl.objects.filter(id=event.id, status=Crawl.StatusChoices.STARTED).first() - if not crawl: - return - crawl.status = Crawl.StatusChoices.SEALED - crawl.save() - yield {'name': 'FS_WRITE', 'path': crawl.OUTPUT_DIR / 'index.json', 'content': json.dumps(crawl.as_json(), default=str, indent=4, sort_keys=True)} - yield {'name': 'CRAWL_UPDATED', 'crawl_id': crawl.id} - - @staticmethod - def on_CRAWL_START(event: Event) -> Iterable[EventDict]: - # create root snapshot - crawl = Crawl.objects.get(id=event.crawl_id) - new_snapshot_id = uuid.uuid4() - yield {'name': 'SNAPSHOT_CREATE', 'snapshot_id': new_snapshot_id, 'crawl_id': crawl.id, 'url': crawl.seed.uri} - yield {'name': 'SNAPSHOT_START', 'snapshot_id': new_snapshot_id} - yield {'name': 'CRAWL_UPDATE', 'crawl_id': crawl.id, 'status': 'started', 'retry_at': None} +# Populate the registry +WORKER_TYPES.update({ + 'crawl': CrawlWorker, + 'snapshot': SnapshotWorker, + 'archiveresult': ArchiveResultWorker, +}) -class SnapshotWorker(WorkerType): - name = 'snapshot' - listens_to = 'SNAPSHOT_' - outputs = ['SNAPSHOT_', 'FS_'] - - @staticmethod - def on_SNAPSHOT_IDLE(event: Event) -> Iterable[EventDict]: - # check for any snapshots that can be started or sealed - snapshot = Snapshot.objects.exclude(status=Snapshot.StatusChoices.SEALED).first() - if not snapshot: - return [] - - if snapshot.can_start(): - yield {'name': 'SNAPSHOT_START', 'id': snapshot.id} - elif snapshot.can_seal(): - yield {'name': 'SNAPSHOT_SEAL', 'id': snapshot.id} - - @staticmethod - def on_SNAPSHOT_CREATE(event: Event) -> Iterable[EventDict]: - snapshot = Snapshot.objects.create(id=event.snapshot_id, **event.kwargs) - yield {'name': 'FS_WRITE', 'path': snapshot.OUTPUT_DIR / 'index.json', 'content': json.dumps(snapshot.as_json(), default=str, indent=4, sort_keys=True)} - yield {'name': 'SNAPSHOT_UPDATED', 'id': snapshot.id} - - @staticmethod - def on_SNAPSHOT_SEAL(event: Event) -> Iterable[EventDict]: - snapshot = Snapshot.objects.get(id=event.snapshot_id, status=Snapshot.StatusChoices.STARTED) - assert snapshot.can_seal() - snapshot.status = Snapshot.StatusChoices.SEALED - snapshot.save() - yield {'name': 'FS_WRITE', 'path': snapshot.OUTPUT_DIR / 'index.json', 'content': json.dumps(snapshot.as_json(), default=str, indent=4, sort_keys=True)} - yield {'name': 'SNAPSHOT_UPDATED', 'id': snapshot.id} - - @staticmethod - def on_SNAPSHOT_START(event: Event) -> Iterable[EventDict]: - snapshot = Snapshot.objects.get(id=event.snapshot_id, status=Snapshot.StatusChoices.QUEUED) - assert snapshot.can_start() - - # create pending archiveresults for each extractor - for extractor in snapshot.get_extractors(): - new_archiveresult_id = uuid.uuid4() - yield {'name': 'ARCHIVERESULT_CREATE', 'id': new_archiveresult_id, 'snapshot_id': snapshot.id, 'extractor': extractor.name} - yield {'name': 'ARCHIVERESULT_START', 'id': new_archiveresult_id} - - snapshot.status = Snapshot.StatusChoices.STARTED - snapshot.save() - yield {'name': 'FS_WRITE', 'path': snapshot.OUTPUT_DIR / 'index.json', 'content': json.dumps(snapshot.as_json(), default=str, indent=4, sort_keys=True)} - yield {'name': 'SNAPSHOT_UPDATED', 'id': snapshot.id} - - - -class ArchiveResultWorker(WorkerType): - name = 'archiveresult' - listens_to = 'ARCHIVERESULT_' - outputs = ['ARCHIVERESULT_', 'FS_'] - - @staticmethod - def on_ARCHIVERESULT_UPDATE(event: Event) -> Iterable[EventDict]: - archiveresult = ArchiveResult.objects.get(id=event.id) - diff = { - key: val - for key, val in event.items() - if getattr(archiveresult, key) != val - } - if diff: - archiveresult.update(**diff) - yield {'name': 'ARCHIVERESULT_UPDATED', 'id': archiveresult.id} - - @staticmethod - def on_ARCHIVERESULT_UPDATED(event: Event) -> Iterable[EventDict]: - archiveresult = ArchiveResult.objects.get(id=event.id) - yield {'name': 'FS_WRITE_SYMLINKS', 'path': archiveresult.OUTPUT_DIR, 'symlinks': archiveresult.output_dir_symlinks} - - @staticmethod - def on_ARCHIVERESULT_CREATE(event: Event) -> Iterable[EventDict]: - archiveresult, created = ArchiveResult.objects.get_or_create(id=event.pop('archiveresult_id'), defaults=event) - if created: - yield {'name': 'ARCHIVERESULT_UPDATE', 'id': archiveresult.id} - else: - diff = { - key: val - for key, val in event.items() - if getattr(archiveresult, key) != val - } - assert not diff, f'ArchiveResult {archiveresult.id} already exists and has different values, cannot create on top of it: {diff}' - - @staticmethod - def on_ARCHIVERESULT_SEAL(event: Event) -> Iterable[EventDict]: - archiveresult = ArchiveResult.objects.get(id=event.id, status=ArchiveResult.StatusChoices.STARTED) - assert archiveresult.can_seal() - yield {'name': 'ARCHIVERESULT_UPDATE', 'id': archiveresult.id, 'status': 'sealed'} - - @staticmethod - def on_ARCHIVERESULT_START(event: Event) -> Iterable[EventDict]: - archiveresult = ArchiveResult.objects.get(id=event.id, status=ArchiveResult.StatusChoices.QUEUED) - - yield { - 'name': 'SHELL_EXEC', - 'cmd': archiveresult.EXTRACTOR.get_cmd(), - 'cwd': archiveresult.OUTPUT_DIR, - 'on_exit': { - 'name': 'ARCHIVERESULT_SEAL', - 'id': archiveresult.id, - }, - } - - archiveresult.status = ArchiveResult.StatusChoices.STARTED - archiveresult.save() - yield {'name': 'FS_WRITE', 'path': archiveresult.OUTPUT_DIR / 'index.json', 'content': json.dumps(archiveresult.as_json(), default=str, indent=4, sort_keys=True)} - yield {'name': 'ARCHIVERESULT_UPDATED', 'id': archiveresult.id} - - @staticmethod - def on_ARCHIVERESULT_IDLE(event: Event) -> Iterable[EventDict]: - stale_archiveresult = ArchiveResult.objects.exclude(status__in=[ArchiveResult.StatusChoices.SUCCEEDED, ArchiveResult.StatusChoices.FAILED]).first() - if not stale_archiveresult: - return [] - if stale_archiveresult.can_start(): - yield {'name': 'ARCHIVERESULT_START', 'id': stale_archiveresult.id} - if stale_archiveresult.can_seal(): - yield {'name': 'ARCHIVERESULT_SEAL', 'id': stale_archiveresult.id} - - -WORKER_TYPES = [ - OrchestratorWorker, - FileSystemWorker, - CrawlWorker, - SnapshotWorker, - ArchiveResultWorker, -] - -def get_worker_type(name: str) -> Type[WorkerType]: - for worker_type in WORKER_TYPES: - matches_verbose_name = (worker_type.name == name) - matches_class_name = (worker_type.__name__.lower() == name.lower()) - matches_listens_to = (worker_type.listens_to.strip('_').lower() == name.strip('_').lower()) - if matches_verbose_name or matches_class_name or matches_listens_to: - return worker_type - raise Exception(f'Worker type not found: {name}') +def get_worker_class(name: str) -> type[Worker]: + """Get worker class by name.""" + if name not in WORKER_TYPES: + raise ValueError(f'Unknown worker type: {name}. Valid types: {list(WORKER_TYPES.keys())}') + return WORKER_TYPES[name] diff --git a/logs/errors.log b/logs/errors.log new file mode 100644 index 00000000..66234c0a --- /dev/null +++ b/logs/errors.log @@ -0,0 +1,112 @@ + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/lib/python3.14/site-packages/pytest/__main__.py archivebox/cli/test_version.py -v --tb=short; TS=2025-12-25__02:17:49 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/lib/python3.14/site-packages/pytest/__main__.py archivebox/cli/tests_piping.py::TestPipingWorkflowIntegration::test_snapshot_creates_and_outputs_jsonl -v --tb=short; TS=2025-12-25__02:18:12 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/lib/python3.14/site-packages/pytest/__main__.py archivebox/cli/test_version.py archivebox/cli/test_install.py -v --tb=short; TS=2025-12-25__02:19:15 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> -c; TS=2025-12-25__02:19:30 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> -c; TS=2025-12-25__02:19:39 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/lib/python3.14/site-packages/pytest/__main__.py archivebox/cli/tests_migrations.py -v --tb=short; TS=2025-12-25__02:23:46 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:28:59 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:01 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:03 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:04 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:06 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:08 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:29:09 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:29:11 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list; TS=2025-12-25__02:29:12 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:29:14 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py init; TS=2025-12-25__02:29:15 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py add https://example.com; TS=2025-12-25__02:29:16 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:31:22 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:31:52 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:32:17 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:33:38 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:33:40 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py add https://wikipedia.org; TS=2025-12-25__02:33:41 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:35:41 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:35:43 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:35:44 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list --json; TS=2025-12-25__02:35:46 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:35:47 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py status; TS=2025-12-25__02:35:49 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:35:50 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:35:51 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list; TS=2025-12-25__02:35:53 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:35:54 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py init; TS=2025-12-25__02:35:56 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py add https://example.com; TS=2025-12-25__02:35:57 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list --json; TS=2025-12-25__02:35:58 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list --help; TS=2025-12-25__02:36:10 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:46 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:48 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:49 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:51 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:52 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py status; TS=2025-12-25__02:36:54 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate; TS=2025-12-25__02:36:55 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:36:56 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py list; TS=2025-12-25__02:36:58 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage migrate --run-syncdb; TS=2025-12-25__02:36:59 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py init; TS=2025-12-25__02:37:00 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py init; TS=2025-12-25__02:37:09 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> -c; TS=2025-12-25__02:38:28 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py crawl --help; TS=2025-12-25__02:53:27 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/archivebox/__main__.py manage makemigrations --dry-run; TS=2025-12-25__03:37:07 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/bin/archivebox manage check; TS=2025-12-25__04:04:43 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/bin/archivebox manage makemigrations --dry-run; TS=2025-12-25__04:04:56 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False + +> /Users/squash/Local/Code/archiveboxes/archivebox-nue/.venv/bin/archivebox manage makemigrations --dry-run; TS=2025-12-25__04:08:01 VERSION=0.8.6rc3 IN_DOCKER=False IS_TTY=False diff --git a/pyproject.toml b/pyproject.toml index e970f4e5..34bbf601 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,7 +41,7 @@ dependencies = [ "setuptools>=74.1.0", # for: django 5 on python >=3.12, distutils is no longer in stdlib but django 5.1 expects distutils (TODO: check if this can be removed eventually) "django>=6.0", "channels[daphne]>=4.1.0", - "django-ninja>=1.3.0", + "django-ninja>=1.5.1", "django-extensions>=3.2.3", "django-huey>=1.2.1", "django-huey-monitor>=0.9.0", @@ -51,7 +51,6 @@ dependencies = [ "django-taggit==6.1.0", # TODO: remove this in favor of KVTags only ### State Management - "pluggy>=1.5.0", # for: archivebox plugin system (abx) "python-statemachine>=2.3.6", ### CLI / Logging @@ -61,7 +60,6 @@ dependencies = [ "ipython>=8.27.0", # for: archivebox shell (TODO: replace with bpython?) ### Host OS / System - "abx-pkg>=0.6.0", # for: Binary, BinProvider, SemVer and archivebox install "supervisor>=4.2.5", # for: archivebox server starting daphne and workers "psutil>=6.0.0", # for: monitoring orchestractor,actors,workers,etc. and machine.models.Process "platformdirs>=4.3.6", # for: finding a xdg-config dir to store tmp/lib files in @@ -71,10 +69,10 @@ dependencies = [ "croniter>=3.0.3", # for: archivebox schedule (TODO: remove this in favor of our own custom archivebox scheduler) ### Base Types - "pydantic>=2.8.0", # for: archivebox.api (django-ninja), Binary & BinProvider (abx-pkg), archivebox.config (pydantic-settings), and archivebox.index.schema (pydantic) + "pydantic>=2.8.0", # for: archivebox.api (django-ninja), archivebox.config (pydantic-settings), and archivebox.index.schema (pydantic) "pydantic-settings>=2.5.2", # for: archivebox.config "python-benedict[io,parse]>=0.33.2", # for: dict replacement all over the codebase to allow .attr-style access - "blake3>=1.0.0", # TODO: remove this in favor of sha256 everywhere? + "base32-crockford>=0.3.0", # for: encoding UUIDs in base32 ### Static Typing "mypy-extensions>=1.0.0", # for: django-stubs type hints (TODO: remove in favor of pylance/pyright?) @@ -91,40 +89,11 @@ dependencies = [ "tzdata>=2024.2", # needed for dateparser {TZ: UTC} on some systems: https://github.com/ArchiveBox/ArchiveBox/issues/1553 "w3lib>=2.2.1", # used for parsing content-type encoding from http response headers & html tags - ### Main Plugin Interfaces - "abx>=0.1.0", - "abx-spec-abx-pkg>=0.1.1", - "abx-spec-config>=0.1.0", - "abx-spec-archivebox>=0.1.0", - "abx-spec-django>=0.1.0", - "abx-spec-extractor>=0.1.0", - "abx-spec-searchbackend>=0.1.0", + ### Extractor dependencies (optional binaries detected at runtime via shutil.which) + "yt-dlp>=2024.1.0", # for: media extractor - ### Default Plugins - "abx-plugin-default-binproviders>=2024.10.24", - "abx-plugin-pip>=2024.10.24", - "abx-plugin-npm>=2024.10.24", - "abx-plugin-playwright>=2024.10.24", - "abx-plugin-puppeteer>=2024.10.28", - "abx-plugin-ripgrep-search>=2024.10.28", - "abx-plugin-sqlitefts-search>=2024.10.28", - "abx-plugin-sonic-search>=2024.10.28", - "abx-plugin-ldap-auth>=2024.10.28", - "abx-plugin-curl>=2024.10.27", - "abx-plugin-wget>=2024.10.28", - "abx-plugin-git>=2024.10.28", - "abx-plugin-chrome>=2024.10.28", - "abx-plugin-ytdlp>=2024.10.28", - "abx-plugin-title>=2024.10.27", - "abx-plugin-favicon>=2024.10.27", - # "abx-plugin-headers>=2024.10.27", - "abx-plugin-archivedotorg>=2024.10.28", - "abx-plugin-singlefile>=2024.10.28", - "abx-plugin-readability>=2024.10.28", - "abx-plugin-mercury>=2024.10.28", - "abx-plugin-htmltotext>=2024.10.28", - # TODO: add gallery-dl - # TODO: add forum-dl + ### Binary/Package Management + "abx-pkg>=0.1.0", # for: detecting, versioning, and installing binaries via apt/brew/pip/npm ] [project.optional-dependencies] @@ -193,50 +162,8 @@ dev-dependencies = [ "mypy>=1.11.2", ] -[tool.uv.sources] -# abx-pkg = { workspace = true } - -abx = { workspace = true } -abx-spec-abx-pkg = { workspace = true } -abx-spec-config = { workspace = true } -abx-spec-archivebox = { workspace = true } -abx-spec-django = { workspace = true } -abx-spec-extractor = { workspace = true } -abx-spec-searchbackend = { workspace = true } - -abx-plugin-default-binproviders = { workspace = true } -abx-plugin-pip = { workspace = true } -abx-plugin-npm = { workspace = true } -abx-plugin-playwright = { workspace = true } -abx-plugin-puppeteer = { workspace = true } -abx-plugin-ripgrep-search = { workspace = true } -abx-plugin-sqlitefts-search = { workspace = true } -abx-plugin-sonic-search = { workspace = true } -abx-plugin-ldap-auth = { workspace = true } - -abx-plugin-curl = { workspace = true } -abx-plugin-wget = { workspace = true } -abx-plugin-git = { workspace = true } -abx-plugin-chrome = { workspace = true } -abx-plugin-ytdlp = { workspace = true } - -abx-plugin-title = { workspace = true } -abx-plugin-favicon = { workspace = true } -# abx-plugin-headers = { workspace = true } -abx-plugin-archivedotorg = { workspace = true } - -abx-plugin-singlefile = { workspace = true } -abx-plugin-readability = { workspace = true } -abx-plugin-mercury = { workspace = true } -abx-plugin-htmltotext = { workspace = true } - - -[tool.uv.workspace] -members = ["archivebox/pkgs/*"] -exclude = ["archivebox/pkgs/__pycache__"] - [tool.uv.pip] -python-version = "3.11" +python-version = "3.14" # compile-bytecode = true [build-system] @@ -250,7 +177,7 @@ package-dir = {"archivebox" = "archivebox"} [tool.ruff] line-length = 140 -target-version = "py310" +target-version = "py314" src = ["archivebox"] exclude = ["*.pyi", "typings/", "migrations/"] @@ -295,7 +222,7 @@ venv = ".venv" # defineConstant = { DEBUG = true } reportMissingImports = true reportMissingTypeStubs = false -pythonVersion = "3.10" +pythonVersion = "3.14" pythonPlatform = "Linux" diff --git a/test_extensions.sh b/test_extensions.sh new file mode 100755 index 00000000..79efc6b2 --- /dev/null +++ b/test_extensions.sh @@ -0,0 +1,101 @@ +#!/bin/bash +set -e + +echo "==========================================" +echo "Testing Chrome Extension System" +echo "==========================================" + +# Get absolute path to project root +PROJECT_ROOT="$(cd "$(dirname "$0")" && pwd)" + +# Set up test environment with absolute paths +export DATA_DIR="$PROJECT_ROOT/data" +export ACTIVE_PERSONA="Test" +export CHROME_EXTENSIONS_DIR="$PROJECT_ROOT/data/personas/Test/chrome_extensions" +export API_KEY_2CAPTCHA="test_api_key_12345" + +# Clean up any previous test data +echo "" +echo "[1/6] Cleaning up previous test data..." +rm -rf "$CHROME_EXTENSIONS_DIR" +rm -rf "$PROJECT_ROOT/chrome_session" +# Also clean up any files created in plugin directories from previous runs +find "$PROJECT_ROOT/archivebox/plugins" -type d -name "data" -exec rm -rf {} + 2>/dev/null || true +mkdir -p "$CHROME_EXTENSIONS_DIR" + +echo "✓ Clean slate ready" + +# Test 1: Install captcha2 extension +echo "" +echo "[2/6] Testing captcha2 extension installation..." +node "$PROJECT_ROOT/archivebox/plugins/captcha2/on_Snapshot__01_captcha2.js" +if [ -f "$CHROME_EXTENSIONS_DIR/captcha2.extension.json" ]; then + echo "✓ captcha2.extension.json created" +else + echo "✗ Failed to create captcha2.extension.json" + exit 1 +fi + +# Test 2: Check caching (run again, should skip) +echo "" +echo "[3/6] Testing cache (should skip re-installation)..." +node "$PROJECT_ROOT/archivebox/plugins/captcha2/on_Snapshot__01_captcha2.js" +echo "✓ Cache check passed" + +# Test 3: Install other extensions +echo "" +echo "[4/6] Testing other extensions..." +node "$PROJECT_ROOT/archivebox/plugins/istilldontcareaboutcookies/on_Snapshot__02_istilldontcareaboutcookies.js" +node "$PROJECT_ROOT/archivebox/plugins/ublock/on_Snapshot__03_ublock.js" +node "$PROJECT_ROOT/archivebox/plugins/singlefile/on_Snapshot__04_singlefile.js" + +echo "✓ All extensions installed" + +# Test 4: List installed extensions +echo "" +echo "[5/6] Verifying extension files..." +ls -lh "$CHROME_EXTENSIONS_DIR"/*.extension.json 2>/dev/null || echo "No extension.json files found" + +# Count extensions +EXT_COUNT=$(ls -1 "$CHROME_EXTENSIONS_DIR"/*.extension.json 2>/dev/null | wc -l | tr -d ' ') +echo "" +echo "Found $EXT_COUNT extension metadata files" + +if [ "$EXT_COUNT" -ge "3" ]; then + echo "✓ Expected extensions installed" +else + echo "✗ Expected at least 3 extensions, found $EXT_COUNT" + exit 1 +fi + +# Test 5: Check unpacked directories +echo "" +echo "[6/6] Checking unpacked extension directories..." +UNPACKED_COUNT=$(find "$CHROME_EXTENSIONS_DIR" -type d -name "*__*" 2>/dev/null | wc -l | tr -d ' ') +echo "Found $UNPACKED_COUNT unpacked extension directories" + +if [ "$UNPACKED_COUNT" -ge "3" ]; then + echo "✓ Extensions unpacked successfully" +else + echo "✗ Expected at least 3 unpacked directories, found $UNPACKED_COUNT" + exit 1 +fi + +# Summary +echo "" +echo "==========================================" +echo "✓ All tests passed!" +echo "==========================================" +echo "" +echo "Installed extensions:" +for json_file in "$CHROME_EXTENSIONS_DIR"/*.extension.json; do + if [ -f "$json_file" ]; then + NAME=$(node -e "console.log(require('$json_file').name)") + VERSION=$(node -e "console.log(require('$json_file').version || 'unknown')") + echo " - $NAME (v$VERSION)" + fi +done + +echo "" +echo "To clean up test data:" +echo " rm -rf ./data/personas/Test" diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 00000000..b9c251c7 --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox config command.""" + +import os +import subprocess + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_config_shows_all_config_values(tmp_path, process): + """Test that config without args shows all config values.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config'], + capture_output=True, + text=True, + ) + + # Should show various config sections + assert 'TIMEOUT' in result.stdout or 'timeout' in result.stdout.lower() + # Config should show some output + assert len(result.stdout) > 100 + + +def test_config_get_specific_key(tmp_path, process): + """Test that --get retrieves a specific config value.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config', '--get', 'TIMEOUT'], + capture_output=True, + text=True, + ) + + # Should show the TIMEOUT value + assert 'TIMEOUT' in result.stdout or result.returncode == 0 + + +def test_config_set_value_writes_to_config_file(tmp_path, process): + """Test that --set writes config value to ArchiveBox.conf file.""" + os.chdir(tmp_path) + + # Set a config value + result = subprocess.run( + ['archivebox', 'config', '--set', 'TIMEOUT=120'], + capture_output=True, + text=True, + ) + + # Read the config file directly to verify it was written + config_file = tmp_path / 'ArchiveBox.conf' + if config_file.exists(): + config_content = config_file.read_text() + # Config should contain the set value + assert 'TIMEOUT' in config_content or 'timeout' in config_content.lower() + + +def test_config_set_and_get_roundtrip(tmp_path, process): + """Test that a value set with --set can be retrieved with --get.""" + os.chdir(tmp_path) + + # Set a value + set_result = subprocess.run( + ['archivebox', 'config', '--set', 'TIMEOUT=999'], + capture_output=True, + text=True, + ) + + # Verify set was successful + assert set_result.returncode == 0 or '999' in set_result.stdout + + # Read the config file directly to verify + config_file = tmp_path / 'ArchiveBox.conf' + if config_file.exists(): + config_content = config_file.read_text() + assert '999' in config_content or 'TIMEOUT' in config_content + + +def test_config_search_finds_matching_keys(tmp_path, process): + """Test that --search finds config keys matching a pattern.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config', '--search', 'TIMEOUT'], + capture_output=True, + text=True, + ) + + # Should find TIMEOUT-related config + assert 'TIMEOUT' in result.stdout or result.returncode == 0 + + +def test_config_invalid_key_fails(tmp_path, process): + """Test that setting an invalid config key fails.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config', '--set', 'INVALID_KEY_THAT_DOES_NOT_EXIST=value'], + capture_output=True, + text=True, + ) + + # Should fail + assert result.returncode != 0 or 'failed' in result.stdout.lower() + + +def test_config_set_requires_equals_sign(tmp_path, process): + """Test that --set requires KEY=VALUE format.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config', '--set', 'TIMEOUT'], + capture_output=True, + text=True, + ) + + # Should fail because there's no = sign + assert result.returncode != 0 + + +class TestConfigCLI: + """Test the CLI interface for config command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for config command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'config', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--get' in result.stdout + assert '--set' in result.stdout + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_crawl.py b/tests/test_crawl.py new file mode 100644 index 00000000..31f1d640 --- /dev/null +++ b/tests/test_crawl.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox crawl command.""" + +import os +import subprocess +import sqlite3 +import json + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_crawl_creates_crawl_object(tmp_path, process, disable_extractors_dict): + """Test that crawl command creates a Crawl object.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + crawl = c.execute("SELECT id, max_depth FROM crawls_crawl ORDER BY created_at DESC LIMIT 1").fetchone() + conn.close() + + assert crawl is not None, "Crawl object should be created" + + +def test_crawl_depth_sets_max_depth_in_crawl(tmp_path, process, disable_extractors_dict): + """Test that --depth option sets max_depth in the Crawl object.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--depth=2', '--no-wait', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + crawl = c.execute("SELECT max_depth FROM crawls_crawl ORDER BY created_at DESC LIMIT 1").fetchone() + conn.close() + + assert crawl is not None + assert crawl[0] == 2, "Crawl max_depth should match --depth=2" + + +def test_crawl_creates_snapshot_for_url(tmp_path, process, disable_extractors_dict): + """Test that crawl creates a Snapshot for the input URL.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot = c.execute("SELECT url FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone() + conn.close() + + assert snapshot is not None, "Snapshot should be created for input URL" + + +def test_crawl_links_snapshot_to_crawl(tmp_path, process, disable_extractors_dict): + """Test that Snapshot is linked to Crawl via crawl_id.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + + # Get the crawl ID + crawl = c.execute("SELECT id FROM crawls_crawl ORDER BY created_at DESC LIMIT 1").fetchone() + assert crawl is not None + crawl_id = crawl[0] + + # Check snapshot has correct crawl_id + snapshot = c.execute("SELECT crawl_id FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone() + conn.close() + + assert snapshot is not None + assert snapshot[0] == crawl_id, "Snapshot should be linked to Crawl" + + +def test_crawl_multiple_urls_creates_multiple_snapshots(tmp_path, process, disable_extractors_dict): + """Test that crawling multiple URLs creates multiple snapshots.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', + 'https://example.com', + 'https://iana.org'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + urls = c.execute("SELECT url FROM core_snapshot ORDER BY url").fetchall() + conn.close() + + urls = [u[0] for u in urls] + assert 'https://example.com' in urls + assert 'https://iana.org' in urls + + +def test_crawl_from_file_creates_snapshot(tmp_path, process, disable_extractors_dict): + """Test that crawl can create snapshots from a file of URLs.""" + os.chdir(tmp_path) + + # Write URLs to a file + urls_file = tmp_path / 'urls.txt' + urls_file.write_text('https://example.com\n') + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', str(urls_file)], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot = c.execute("SELECT url FROM core_snapshot").fetchone() + conn.close() + + # Should create at least one snapshot (the source file or the URL) + assert snapshot is not None, "Should create at least one snapshot" + + +def test_crawl_creates_seed_for_input(tmp_path, process, disable_extractors_dict): + """Test that crawl creates a Seed object for input.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'crawl', '--no-wait', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + seed = c.execute("SELECT id FROM crawls_seed").fetchone() + conn.close() + + assert seed is not None, "Seed should be created for crawl input" + + +class TestCrawlCLI: + """Test the CLI interface for crawl command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for crawl command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'crawl', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--depth' in result.stdout or '-d' in result.stdout + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_extract.py b/tests/test_extract.py new file mode 100644 index 00000000..117c922f --- /dev/null +++ b/tests/test_extract.py @@ -0,0 +1,277 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox extract command.""" + +import os +import subprocess +import sqlite3 +import json + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_extract_runs_on_snapshot_id(tmp_path, process, disable_extractors_dict): + """Test that extract command accepts a snapshot ID.""" + os.chdir(tmp_path) + + # First create a snapshot + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get the snapshot ID + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_id = c.execute("SELECT id FROM core_snapshot LIMIT 1").fetchone()[0] + conn.close() + + # Run extract on the snapshot + result = subprocess.run( + ['archivebox', 'extract', '--no-wait', str(snapshot_id)], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Should not error about invalid snapshot ID + assert 'not found' not in result.stderr.lower() + + +def test_extract_with_enabled_extractor_creates_archiveresult(tmp_path, process, disable_extractors_dict): + """Test that extract creates ArchiveResult when extractor is enabled.""" + os.chdir(tmp_path) + + # First create a snapshot + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get the snapshot ID + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_id = c.execute("SELECT id FROM core_snapshot LIMIT 1").fetchone()[0] + conn.close() + + # Run extract with title extractor enabled + env = disable_extractors_dict.copy() + env['SAVE_TITLE'] = 'true' + + subprocess.run( + ['archivebox', 'extract', '--no-wait', str(snapshot_id)], + capture_output=True, + text=True, + env=env, + ) + + # Check for archiveresults (may be queued, not completed with --no-wait) + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + count = c.execute("SELECT COUNT(*) FROM core_archiveresult WHERE snapshot_id = ?", + (snapshot_id,)).fetchone()[0] + conn.close() + + # May or may not have results depending on timing + assert count >= 0 + + +def test_extract_plugin_option_accepted(tmp_path, process, disable_extractors_dict): + """Test that --plugin option is accepted.""" + os.chdir(tmp_path) + + # First create a snapshot + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get the snapshot ID + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_id = c.execute("SELECT id FROM core_snapshot LIMIT 1").fetchone()[0] + conn.close() + + result = subprocess.run( + ['archivebox', 'extract', '--plugin=title', '--no-wait', str(snapshot_id)], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + assert 'unrecognized arguments: --plugin' not in result.stderr + + +def test_extract_stdin_snapshot_id(tmp_path, process, disable_extractors_dict): + """Test that extract reads snapshot IDs from stdin.""" + os.chdir(tmp_path) + + # First create a snapshot + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get the snapshot ID + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_id = c.execute("SELECT id FROM core_snapshot LIMIT 1").fetchone()[0] + conn.close() + + result = subprocess.run( + ['archivebox', 'extract', '--no-wait'], + input=f'{snapshot_id}\n', + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Should not show "not found" error + assert 'not found' not in result.stderr.lower() or result.returncode == 0 + + +def test_extract_stdin_jsonl_input(tmp_path, process, disable_extractors_dict): + """Test that extract reads JSONL records from stdin.""" + os.chdir(tmp_path) + + # First create a snapshot + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get the snapshot ID + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_id = c.execute("SELECT id FROM core_snapshot LIMIT 1").fetchone()[0] + conn.close() + + jsonl_input = json.dumps({"type": "Snapshot", "id": str(snapshot_id)}) + '\n' + + result = subprocess.run( + ['archivebox', 'extract', '--no-wait'], + input=jsonl_input, + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Should not show "not found" error + assert 'not found' not in result.stderr.lower() or result.returncode == 0 + + +def test_extract_pipeline_from_snapshot(tmp_path, process, disable_extractors_dict): + """Test piping snapshot output to extract.""" + os.chdir(tmp_path) + + # Create snapshot and pipe to extract + snapshot_proc = subprocess.Popen( + ['archivebox', 'snapshot', 'https://example.com'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env=disable_extractors_dict, + ) + + subprocess.run( + ['archivebox', 'extract', '--no-wait'], + stdin=snapshot_proc.stdout, + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + snapshot_proc.wait() + + # Check database for snapshot + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot = c.execute("SELECT id, url FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone() + conn.close() + + assert snapshot is not None, "Snapshot should be created by pipeline" + + +def test_extract_multiple_snapshots(tmp_path, process, disable_extractors_dict): + """Test extracting from multiple snapshots.""" + os.chdir(tmp_path) + + # Create multiple snapshots one at a time to avoid deduplication issues + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://iana.org'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Get all snapshot IDs + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + snapshot_ids = c.execute("SELECT id FROM core_snapshot").fetchall() + conn.close() + + assert len(snapshot_ids) >= 2, "Should have at least 2 snapshots" + + # Extract from all snapshots + ids_input = '\n'.join(str(s[0]) for s in snapshot_ids) + '\n' + result = subprocess.run( + ['archivebox', 'extract', '--no-wait'], + input=ids_input, + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Should not error + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + count = c.execute("SELECT COUNT(*) FROM core_snapshot").fetchone()[0] + conn.close() + + assert count >= 2, "Both snapshots should still exist after extraction" + + +class TestExtractCLI: + """Test the CLI interface for extract command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for extract command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'extract', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--plugin' in result.stdout or '-p' in result.stdout + assert '--wait' in result.stdout or '--no-wait' in result.stdout + + def test_cli_no_snapshots_shows_warning(self, tmp_path, process): + """Test that running without snapshots shows a warning.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'extract', '--no-wait'], + input='', + capture_output=True, + text=True, + ) + + # Should show warning about no snapshots or exit normally (empty input) + assert result.returncode == 0 or 'No' in result.stderr + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_install.py b/tests/test_install.py new file mode 100644 index 00000000..3106ddb1 --- /dev/null +++ b/tests/test_install.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox install command.""" + +import os +import subprocess +import sqlite3 + +import pytest + +from .fixtures import process, disable_extractors_dict + + +class TestInstallDryRun: + """Test the dry-run mode of install command.""" + + def test_dry_run_prints_message(self, tmp_path, process): + """Test that dry-run mode prints appropriate message.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'install', '--dry-run'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert 'Dry run' in result.stdout + + def test_dry_run_does_not_create_crawl(self, tmp_path, process): + """Test that dry-run mode doesn't create a crawl.""" + os.chdir(tmp_path) + + # Get initial crawl count + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + c.execute("SELECT COUNT(*) FROM crawls_crawl") + initial_count = c.fetchone()[0] + conn.close() + + # Run install with dry-run + result = subprocess.run( + ['archivebox', 'install', '--dry-run'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + + # Check crawl count unchanged + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + c.execute("SELECT COUNT(*) FROM crawls_crawl") + final_count = c.fetchone()[0] + conn.close() + + assert final_count == initial_count + + +class TestInstallOutput: + """Test the output/messages from install command.""" + + def test_install_prints_detecting_message(self, tmp_path, process, disable_extractors_dict): + """Test that install prints detecting dependencies message.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'install', '--dry-run'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + assert result.returncode == 0 + # Should mention detecting or dependencies + output = result.stdout.lower() + assert 'detect' in output or 'dependenc' in output or 'dry run' in output + + +class TestInstallCLI: + """Test the CLI interface for install command.""" + + def test_cli_help(self, tmp_path): + """Test that --help works for install command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'install', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--dry-run' in result.stdout or '-d' in result.stdout + + def test_cli_invalid_option(self, tmp_path): + """Test that invalid options are handled.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'install', '--invalid-option'], + capture_output=True, + text=True, + ) + + # Should fail with non-zero exit code + assert result.returncode != 0 + + +class TestInstallInitialization: + """Test that install initializes the data directory if needed.""" + + def test_install_from_empty_dir(self, tmp_path): + """Test that install from empty dir initializes first.""" + os.chdir(tmp_path) + + # Don't use process fixture - start from empty dir + result = subprocess.run( + ['archivebox', 'install', '--dry-run'], + capture_output=True, + text=True, + ) + + # Should either initialize or show dry run message + output = result.stdout + assert 'Initializing' in output or 'Dry run' in output or 'init' in output.lower() + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_schedule.py b/tests/test_schedule.py new file mode 100644 index 00000000..45e2d222 --- /dev/null +++ b/tests/test_schedule.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox schedule command.""" + +import os +import subprocess + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_schedule_show_lists_jobs(tmp_path, process): + """Test that --show lists current scheduled jobs.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'schedule', '--show'], + capture_output=True, + text=True, + ) + + # Should either show jobs or indicate no jobs + assert 'no' in result.stdout.lower() or 'archivebox' in result.stdout.lower() or result.returncode == 0 + + +def test_schedule_clear_removes_jobs(tmp_path, process): + """Test that --clear removes scheduled jobs.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'schedule', '--clear'], + capture_output=True, + text=True, + ) + + # Should complete successfully (may have no jobs to clear) + assert result.returncode == 0 + + +def test_schedule_every_requires_valid_period(tmp_path, process): + """Test that --every requires valid time period.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'schedule', '--every=invalid_period', 'https://example.com/feed.xml'], + capture_output=True, + text=True, + ) + + # Should fail with invalid period + assert result.returncode != 0 or 'invalid' in result.stdout.lower() + + +class TestScheduleCLI: + """Test the CLI interface for schedule command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for schedule command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'schedule', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--every' in result.stdout + assert '--show' in result.stdout + assert '--clear' in result.stdout + assert '--depth' in result.stdout + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_search.py b/tests/test_search.py new file mode 100644 index 00000000..31d944db --- /dev/null +++ b/tests/test_search.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox search command.""" + +import os +import subprocess +import sqlite3 +import json + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_search_returns_snapshots(tmp_path, process, disable_extractors_dict): + """Test that search returns snapshots.""" + os.chdir(tmp_path) + + # Add some snapshots + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'search'], + capture_output=True, + text=True, + ) + + # Should return some output (path or URL info) + assert result.stdout.strip() != '' or result.returncode == 0 + + +def test_search_filter_by_substring(tmp_path, process, disable_extractors_dict): + """Test that substring filter works.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + # Search with filter - may not find if URL isn't stored as expected + result = subprocess.run( + ['archivebox', 'search', '--filter-type=substring', 'example'], + capture_output=True, + text=True, + ) + + # Should run without error + assert result.returncode == 0 or 'No Snapshots' in result.stderr + + +def test_search_sort_option(tmp_path, process, disable_extractors_dict): + """Test that --sort option works.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'search', '--sort=url'], + capture_output=True, + text=True, + ) + + # Should run without error + assert result.returncode == 0 + + +def test_search_with_headers_requires_format(tmp_path, process): + """Test that --with-headers requires --json, --html, or --csv.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'search', '--with-headers'], + capture_output=True, + text=True, + ) + + # Should fail with error message + assert result.returncode != 0 + assert 'requires' in result.stderr.lower() or 'json' in result.stderr.lower() + + +def test_search_status_option(tmp_path, process, disable_extractors_dict): + """Test that --status option filters by status.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'search', '--status=indexed'], + capture_output=True, + text=True, + ) + + # Should run without error + assert result.returncode == 0 + + +def test_search_no_snapshots_message(tmp_path, process): + """Test that searching empty archive shows appropriate output.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'search'], + capture_output=True, + text=True, + ) + + # Should complete (empty results are OK) + assert result.returncode == 0 + + +class TestSearchCLI: + """Test the CLI interface for search command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for search command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'search', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--filter-type' in result.stdout or '-f' in result.stdout + assert '--status' in result.stdout + assert '--sort' in result.stdout + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_snapshot.py b/tests/test_snapshot.py new file mode 100644 index 00000000..7ca8e5c8 --- /dev/null +++ b/tests/test_snapshot.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox snapshot command.""" + +import os +import subprocess +import sqlite3 +import json + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_snapshot_creates_snapshot_with_correct_url(tmp_path, process, disable_extractors_dict): + """Test that snapshot stores the exact URL in the database.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'snapshot', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + result = c.execute("SELECT url FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone() + conn.close() + + assert result is not None + assert result[0] == 'https://example.com' + + +def test_snapshot_multiple_urls_creates_multiple_records(tmp_path, process, disable_extractors_dict): + """Test that multiple URLs each get their own snapshot record.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'snapshot', + 'https://example.com', + 'https://iana.org'], + capture_output=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + urls = c.execute("SELECT url FROM core_snapshot ORDER BY url").fetchall() + conn.close() + + urls = [u[0] for u in urls] + assert 'https://example.com' in urls + assert 'https://iana.org' in urls + assert len(urls) >= 2 + + +def test_snapshot_tag_creates_tag_and_links_to_snapshot(tmp_path, process, disable_extractors_dict): + """Test that --tag creates tag record and links it to the snapshot.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'snapshot', '--tag=mytesttag', + 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + + # Verify tag was created + tag = c.execute("SELECT id, name FROM core_tag WHERE name = ?", ('mytesttag',)).fetchone() + assert tag is not None, "Tag 'mytesttag' should exist in core_tag" + tag_id = tag[0] + + # Verify snapshot exists + snapshot = c.execute("SELECT id FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone() + assert snapshot is not None + snapshot_id = snapshot[0] + + # Verify tag is linked to snapshot via join table + link = c.execute(""" + SELECT * FROM core_snapshot_tags + WHERE snapshot_id = ? AND tag_id = ? + """, (snapshot_id, tag_id)).fetchone() + conn.close() + + assert link is not None, "Tag should be linked to snapshot via core_snapshot_tags" + + +def test_snapshot_jsonl_output_has_correct_structure(tmp_path, process, disable_extractors_dict): + """Test that JSONL output contains required fields with correct types.""" + os.chdir(tmp_path) + + # Pass URL as argument instead of stdin for more reliable behavior + result = subprocess.run( + ['archivebox', 'snapshot', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Parse JSONL output lines + snapshot_records = [] + for line in result.stdout.strip().split('\n'): + if line: + try: + record = json.loads(line) + if record.get('type') == 'Snapshot': + snapshot_records.append(record) + except json.JSONDecodeError: + continue + + assert len(snapshot_records) >= 1, "Should output at least one Snapshot JSONL record" + + record = snapshot_records[0] + assert record.get('type') == 'Snapshot' + assert 'id' in record, "Snapshot record should have 'id' field" + assert 'url' in record, "Snapshot record should have 'url' field" + assert record['url'] == 'https://example.com' + + +def test_snapshot_with_tag_stores_tag_name(tmp_path, process, disable_extractors_dict): + """Test that title is stored when provided via tag option.""" + os.chdir(tmp_path) + + # Use command line args instead of stdin + subprocess.run( + ['archivebox', 'snapshot', '--tag=customtag', 'https://example.com'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + + # Verify tag was created with correct name + tag = c.execute("SELECT name FROM core_tag WHERE name = ?", + ('customtag',)).fetchone() + conn.close() + + assert tag is not None + assert tag[0] == 'customtag' + + +def test_snapshot_with_depth_creates_crawl_object(tmp_path, process, disable_extractors_dict): + """Test that --depth > 0 creates a Crawl object with correct max_depth.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'snapshot', '--depth=1', + 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + crawl = c.execute("SELECT max_depth FROM crawls_crawl ORDER BY created_at DESC LIMIT 1").fetchone() + conn.close() + + assert crawl is not None, "Crawl object should be created when depth > 0" + assert crawl[0] == 1, "Crawl max_depth should match --depth value" + + +def test_snapshot_deduplicates_urls(tmp_path, process, disable_extractors_dict): + """Test that adding the same URL twice doesn't create duplicate snapshots.""" + os.chdir(tmp_path) + + # Add same URL twice + subprocess.run( + ['archivebox', 'snapshot', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + subprocess.run( + ['archivebox', 'snapshot', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + conn = sqlite3.connect('index.sqlite3') + c = conn.cursor() + count = c.execute("SELECT COUNT(*) FROM core_snapshot WHERE url = ?", + ('https://example.com',)).fetchone()[0] + conn.close() + + assert count == 1, "Same URL should not create duplicate snapshots" + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_status.py b/tests/test_status.py new file mode 100644 index 00000000..2599f053 --- /dev/null +++ b/tests/test_status.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox status command.""" + +import os +import subprocess +import sqlite3 + +import pytest + +from .fixtures import process, disable_extractors_dict + + +def test_status_shows_index_info(tmp_path, process): + """Test that status shows index information.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show index scanning info + assert 'index' in result.stdout.lower() or 'Index' in result.stdout + + +def test_status_shows_snapshot_count(tmp_path, process, disable_extractors_dict): + """Test that status shows snapshot count.""" + os.chdir(tmp_path) + + # Add some snapshots + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://iana.org'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show link/snapshot count + assert '2' in result.stdout or 'links' in result.stdout.lower() + + +def test_status_shows_archive_size(tmp_path, process, disable_extractors_dict): + """Test that status shows archive size information.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show size info (bytes, KB, MB, etc) + assert 'Size' in result.stdout or 'size' in result.stdout or 'B' in result.stdout + + +def test_status_shows_indexed_count(tmp_path, process, disable_extractors_dict): + """Test that status shows indexed folder count.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show indexed count + assert 'indexed' in result.stdout.lower() + + +def test_status_shows_archived_vs_unarchived(tmp_path, process, disable_extractors_dict): + """Test that status shows archived vs unarchived counts.""" + os.chdir(tmp_path) + + # Add index-only snapshot (unarchived) + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show archived/unarchived categories + assert 'archived' in result.stdout.lower() or 'unarchived' in result.stdout.lower() + + +def test_status_shows_data_directory_info(tmp_path, process): + """Test that status shows data directory path.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show data directory or archive path + assert 'archive' in result.stdout.lower() or str(tmp_path) in result.stdout + + +def test_status_shows_user_info(tmp_path, process): + """Test that status shows user information.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show user info section + assert 'user' in result.stdout.lower() or 'login' in result.stdout.lower() + + +def test_status_empty_archive(tmp_path, process): + """Test status on empty archive shows zero counts.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should still run successfully + assert result.returncode == 0 or 'index' in result.stdout.lower() + # Should show 0 links + assert '0' in result.stdout or 'links' in result.stdout.lower() + + +def test_status_shows_valid_vs_invalid(tmp_path, process, disable_extractors_dict): + """Test that status shows valid vs invalid folder counts.""" + os.chdir(tmp_path) + + subprocess.run( + ['archivebox', 'add', '--index-only', 'https://example.com'], + capture_output=True, + env=disable_extractors_dict, + ) + + result = subprocess.run( + ['archivebox', 'status'], + capture_output=True, + text=True, + ) + + # Should show valid/invalid categories + assert 'valid' in result.stdout.lower() or 'present' in result.stdout.lower() + + +class TestStatusCLI: + """Test the CLI interface for status command.""" + + def test_cli_help(self, tmp_path, process): + """Test that --help works for status command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'status', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + # Help should show some info about the command + assert 'status' in result.stdout.lower() or 'statistic' in result.stdout.lower() + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_version.py b/tests/test_version.py new file mode 100644 index 00000000..ccad5bfc --- /dev/null +++ b/tests/test_version.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +"""Integration tests for archivebox version command.""" + +import os +import subprocess +import json + +import pytest + +from .fixtures import process, disable_extractors_dict + + +class TestVersionQuiet: + """Test the quiet/minimal version output.""" + + def test_version_prints_version_number(self, tmp_path): + """Test that version prints the version number.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version', '--quiet'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + # Should contain a version string like "0.8.0" or similar + version = result.stdout.strip() + assert version + # Version should be a valid semver-ish format + parts = version.split('.') + assert len(parts) >= 2 # At least major.minor + + def test_version_flag_prints_version_number(self, tmp_path): + """Test that --version flag prints the version number.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', '--version'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + version = result.stdout.strip() + assert version + parts = version.split('.') + assert len(parts) >= 2 + + +class TestVersionFull: + """Test the full version output.""" + + def test_version_shows_system_info(self, tmp_path, process): + """Test that version shows system information.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version'], + capture_output=True, + text=True, + ) + + output = result.stdout + + # Should show basic system info (exit code may be 1 if binaries missing) + assert 'ArchiveBox' in output + + def test_version_shows_binary_section(self, tmp_path, process): + """Test that version shows binary dependencies section.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version'], + capture_output=True, + text=True, + ) + + output = result.stdout + + # Should show binary dependencies section + assert 'Binary' in output or 'Dependenc' in output + + def test_version_shows_data_locations(self, tmp_path, process): + """Test that version shows data locations.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version'], + capture_output=True, + text=True, + ) + + output = result.stdout + + # Should show data/code locations + assert 'Data' in output or 'location' in output.lower() or 'DIR' in output or 'Code' in output + + +class TestVersionWithInstalledBinaries: + """Test version output after running install.""" + + def test_version_shows_binary_status(self, tmp_path, process, disable_extractors_dict): + """Test that version shows binary status (installed or not).""" + os.chdir(tmp_path) + + # First run install (with dry-run to speed up) + subprocess.run( + ['archivebox', 'install', '--dry-run'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + # Now check version + result = subprocess.run( + ['archivebox', 'version'], + capture_output=True, + text=True, + env=disable_extractors_dict, + ) + + output = result.stdout + + # Should show binary status (either installed or not installed) + assert 'installed' in output.lower() or 'Binary' in output + + +class TestVersionCLI: + """Test the CLI interface for version command.""" + + def test_cli_help(self, tmp_path): + """Test that --help works for version command.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version', '--help'], + capture_output=True, + text=True, + ) + + assert result.returncode == 0 + assert '--quiet' in result.stdout or '-q' in result.stdout + + def test_cli_invalid_option(self, tmp_path): + """Test that invalid options are handled.""" + os.chdir(tmp_path) + + result = subprocess.run( + ['archivebox', 'version', '--invalid-option'], + capture_output=True, + text=True, + ) + + # Should fail with non-zero exit code + assert result.returncode != 0 + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/uv.lock b/uv.lock index 8bb3f9f2..c500ca23 100644 --- a/uv.lock +++ b/uv.lock @@ -1,622 +1,43 @@ version = 1 -requires-python = ">=3.10" +revision = 2 +requires-python = ">=3.14" resolution-markers = [ - "python_full_version < '3.11' and sys_platform == 'darwin'", - "python_full_version >= '3.11' and sys_platform == 'darwin'", - "python_full_version < '3.11' and sys_platform == 'linux'", - "python_full_version >= '3.11' and sys_platform == 'linux'", + "sys_platform == 'darwin'", + "sys_platform == 'linux'", ] supported-markers = [ "sys_platform == 'darwin'", "sys_platform == 'linux'", ] -[manifest] -members = [ - "abx", - "abx-plugin-archivedotorg", - "abx-plugin-chrome", - "abx-plugin-curl", - "abx-plugin-default-binproviders", - "abx-plugin-favicon", - "abx-plugin-git", - "abx-plugin-htmltotext", - "abx-plugin-ldap-auth", - "abx-plugin-mercury", - "abx-plugin-npm", - "abx-plugin-pip", - "abx-plugin-playwright", - "abx-plugin-pocket", - "abx-plugin-puppeteer", - "abx-plugin-readability", - "abx-plugin-readwise", - "abx-plugin-ripgrep-search", - "abx-plugin-singlefile", - "abx-plugin-sonic-search", - "abx-plugin-sqlitefts-search", - "abx-plugin-title", - "abx-plugin-wget", - "abx-plugin-ytdlp", - "abx-spec-abx-pkg", - "abx-spec-archivebox", - "abx-spec-config", - "abx-spec-django", - "abx-spec-extractor", - "abx-spec-searchbackend", - "archivebox", -] - -[[package]] -name = "abx" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx" } -dependencies = [ - { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pluggy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "django", specifier = ">=5.1.1,<6.0" }, - { name = "pluggy", specifier = ">=1.5.0" }, -] - -[[package]] -name = "abx-pkg" -version = "0.6.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pip", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "platformdirs", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/61/13/d14cbe8cb0713cc6d7e10039d615585b5fad5ce5ed67af51f306a3143ffe/abx_pkg-0.6.0.tar.gz", hash = "sha256:a4ceae2ffd619e6b0d6556fc1e7f361a9ef5d33e158a1d85ae39b97677dc98ea", size = 99389 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/a3/57728ed5e1fcaba39af65716c37eb3cee5183605f69890b13576faadb00d/abx_pkg-0.6.0-py3-none-any.whl", hash = "sha256:22bad7d8dd1da3498770f16abdf9d54f3ff8476748d048a88ba10915d9a81037", size = 44167 }, -] - -[[package]] -name = "abx-plugin-archivedotorg" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-archivedotorg" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-curl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-plugin-curl", editable = "archivebox/pkgs/abx-plugin-curl" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-chrome" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-chrome" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-curl" -version = "2024.10.24" -source = { editable = "archivebox/pkgs/abx-plugin-curl" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-default-binproviders" -version = "2024.10.24" -source = { editable = "archivebox/pkgs/abx-plugin-default-binproviders" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, -] - -[[package]] -name = "abx-plugin-favicon" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-favicon" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-curl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-plugin-curl", editable = "archivebox/pkgs/abx-plugin-curl" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-git" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-git" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-default-binproviders", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-plugin-default-binproviders", editable = "archivebox/pkgs/abx-plugin-default-binproviders" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-htmltotext" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-htmltotext" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-ldap-auth" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-ldap-auth" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "abx-spec-django", editable = "archivebox/pkgs/abx-spec-django" }, -] - -[[package]] -name = "abx-plugin-mercury" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-mercury" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-npm" -version = "2024.10.24" -source = { editable = "archivebox/pkgs/abx-plugin-npm" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-default-binproviders", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-plugin-default-binproviders", editable = "archivebox/pkgs/abx-plugin-default-binproviders" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-pip" -version = "2024.10.24" -source = { editable = "archivebox/pkgs/abx-plugin-pip" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-default-binproviders", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-plugin-default-binproviders", editable = "archivebox/pkgs/abx-plugin-default-binproviders" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "django", specifier = ">=5.0.0" }, -] - -[[package]] -name = "abx-plugin-playwright" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-playwright" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "pydantic", specifier = ">=2.4.2" }, -] - -[[package]] -name = "abx-plugin-pocket" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-pocket" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pocket", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "pocket", specifier = ">=0.3.6" }, -] - -[[package]] -name = "abx-plugin-puppeteer" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-puppeteer" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-readability" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-readability" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-readwise" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-readwise" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-ripgrep-search" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-ripgrep-search" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-searchbackend", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "abx-spec-searchbackend", editable = "archivebox/pkgs/abx-spec-searchbackend" }, -] - -[[package]] -name = "abx-plugin-singlefile" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-singlefile" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-sonic-search" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-sonic-search" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-searchbackend", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "abx-spec-searchbackend", editable = "archivebox/pkgs/abx-spec-searchbackend" }, -] - -[[package]] -name = "abx-plugin-sqlitefts-search" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-sqlitefts-search" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-searchbackend", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "abx-spec-searchbackend", editable = "archivebox/pkgs/abx-spec-searchbackend" }, -] - -[[package]] -name = "abx-plugin-title" -version = "2024.10.27" -source = { editable = "archivebox/pkgs/abx-plugin-title" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-curl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-plugin-curl", editable = "archivebox/pkgs/abx-plugin-curl" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-wget" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-wget" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-plugin-ytdlp" -version = "2024.10.28" -source = { editable = "archivebox/pkgs/abx-plugin-ytdlp" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.5.4" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, -] - -[[package]] -name = "abx-spec-abx-pkg" -version = "0.1.1" -source = { editable = "archivebox/pkgs/abx-spec-abx-pkg" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.6.0" }, -] - -[[package]] -name = "abx-spec-archivebox" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx-spec-archivebox" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "django", specifier = ">=5.1.1,<6.0" }, -] - -[[package]] -name = "abx-spec-config" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx-spec-config" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic-settings", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "python-benedict", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "pydantic", specifier = ">=2.9.2" }, - { name = "pydantic-settings", specifier = ">=2.6.0" }, - { name = "python-benedict", specifier = ">=0.34.0" }, - { name = "rich", specifier = ">=13.9.3" }, -] - -[[package]] -name = "abx-spec-django" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx-spec-django" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "django", specifier = ">=5.1.1,<6.0" }, -] - -[[package]] -name = "abx-spec-extractor" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx-spec-extractor" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "python-benedict", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "pydantic", specifier = ">=2.5.0" }, - { name = "python-benedict", specifier = ">=0.26.0" }, -] - -[[package]] -name = "abx-spec-searchbackend" -version = "0.1.0" -source = { editable = "archivebox/pkgs/abx-spec-searchbackend" } -dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "python-benedict", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] - -[package.metadata] -requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "pydantic", specifier = ">=2.5.0" }, - { name = "python-benedict", specifier = ">=0.26.0" }, -] - [[package]] name = "alabaster" version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210 } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929 }, + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, ] [[package]] name = "annotated-types" version = "0.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, ] [[package]] name = "anyio" -version = "4.7.0" +version = "4.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "exceptiongroup", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, { name = "idna", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "sniffio", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.13' and sys_platform == 'darwin') or (python_full_version < '3.13' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f6/40/318e58f669b1a9e00f5c4453910682e2d9dd594334539c7b7817dabb765f/anyio-4.7.0.tar.gz", hash = "sha256:2f834749c602966b7d456a7567cafcb309f96482b5081d14ac93ccd457f9dd48", size = 177076 } +sdist = { url = "https://files.pythonhosted.org/packages/16/ce/8a777047513153587e5434fd752e89334ac33e379aa3497db860eeb60377/anyio-4.12.0.tar.gz", hash = "sha256:73c693b567b0c55130c104d0b43a9baf3aa6a31fc6110116509f27bf75e21ec0", size = 228266, upload-time = "2025-11-28T23:37:38.911Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/7a/4daaf3b6c08ad7ceffea4634ec206faeff697526421c20f07628c7372156/anyio-4.7.0-py3-none-any.whl", hash = "sha256:ea60c3723ab42ba6fff7e8ccb0488c898ec538ff4df1f1d5e642c3601d07e352", size = 93052 }, + { url = "https://files.pythonhosted.org/packages/7f/9c/36c5c37947ebfb8c7f22e0eb6e4d188ee2d53aa3880f3f2744fb894f0cb1/anyio-4.12.0-py3-none-any.whl", hash = "sha256:dad2376a628f98eeca4881fc56cd06affd18f659b17a747d3ff0307ced94b1bb", size = 113362, upload-time = "2025-11-28T23:36:57.897Z" }, ] [[package]] @@ -624,45 +45,14 @@ name = "archivebox" version = "0.8.6rc3" source = { editable = "." } dependencies = [ - { name = "abx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-archivedotorg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-chrome", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-curl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-default-binproviders", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-favicon", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-git", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-htmltotext", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-ldap-auth", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-mercury", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-npm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-pip", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-playwright", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-puppeteer", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-readability", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-ripgrep-search", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-singlefile", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-sonic-search", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-sqlitefts-search", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-title", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-wget", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-plugin-ytdlp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-abx-pkg", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-archivebox", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-config", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-extractor", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "abx-spec-searchbackend", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "atomicwrites", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "base32-crockford", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "blake3", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "channels", extra = ["daphne"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "croniter", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "dateparser", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-admin-data-views", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "django-charid-field", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-huey", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-huey-monitor", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -675,7 +65,6 @@ dependencies = [ { name = "ipython", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "mypy-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "platformdirs", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "pluggy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pocket", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "psutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "py-machineid", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -690,10 +79,9 @@ dependencies = [ { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sonic-client", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "supervisor", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typeid-python", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "tzdata", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "ulid-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "w3lib", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "yt-dlp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] [package.optional-dependencies] @@ -748,53 +136,22 @@ dev = [ [package.metadata] requires-dist = [ - { name = "abx", editable = "archivebox/pkgs/abx" }, - { name = "abx-pkg", specifier = ">=0.6.0" }, - { name = "abx-plugin-archivedotorg", editable = "archivebox/pkgs/abx-plugin-archivedotorg" }, - { name = "abx-plugin-chrome", editable = "archivebox/pkgs/abx-plugin-chrome" }, - { name = "abx-plugin-curl", editable = "archivebox/pkgs/abx-plugin-curl" }, - { name = "abx-plugin-default-binproviders", editable = "archivebox/pkgs/abx-plugin-default-binproviders" }, - { name = "abx-plugin-favicon", editable = "archivebox/pkgs/abx-plugin-favicon" }, - { name = "abx-plugin-git", editable = "archivebox/pkgs/abx-plugin-git" }, - { name = "abx-plugin-htmltotext", editable = "archivebox/pkgs/abx-plugin-htmltotext" }, - { name = "abx-plugin-ldap-auth", editable = "archivebox/pkgs/abx-plugin-ldap-auth" }, - { name = "abx-plugin-mercury", editable = "archivebox/pkgs/abx-plugin-mercury" }, - { name = "abx-plugin-npm", editable = "archivebox/pkgs/abx-plugin-npm" }, - { name = "abx-plugin-pip", editable = "archivebox/pkgs/abx-plugin-pip" }, - { name = "abx-plugin-playwright", editable = "archivebox/pkgs/abx-plugin-playwright" }, - { name = "abx-plugin-puppeteer", editable = "archivebox/pkgs/abx-plugin-puppeteer" }, - { name = "abx-plugin-readability", editable = "archivebox/pkgs/abx-plugin-readability" }, - { name = "abx-plugin-ripgrep-search", editable = "archivebox/pkgs/abx-plugin-ripgrep-search" }, - { name = "abx-plugin-singlefile", editable = "archivebox/pkgs/abx-plugin-singlefile" }, - { name = "abx-plugin-sonic-search", editable = "archivebox/pkgs/abx-plugin-sonic-search" }, - { name = "abx-plugin-sqlitefts-search", editable = "archivebox/pkgs/abx-plugin-sqlitefts-search" }, - { name = "abx-plugin-title", editable = "archivebox/pkgs/abx-plugin-title" }, - { name = "abx-plugin-wget", editable = "archivebox/pkgs/abx-plugin-wget" }, - { name = "abx-plugin-ytdlp", editable = "archivebox/pkgs/abx-plugin-ytdlp" }, - { name = "abx-spec-abx-pkg", editable = "archivebox/pkgs/abx-spec-abx-pkg" }, - { name = "abx-spec-archivebox", editable = "archivebox/pkgs/abx-spec-archivebox" }, - { name = "abx-spec-config", editable = "archivebox/pkgs/abx-spec-config" }, - { name = "abx-spec-django", editable = "archivebox/pkgs/abx-spec-django" }, - { name = "abx-spec-extractor", editable = "archivebox/pkgs/abx-spec-extractor" }, - { name = "abx-spec-searchbackend", editable = "archivebox/pkgs/abx-spec-searchbackend" }, { name = "archivebox", extras = ["sonic", "ldap", "debug"], marker = "extra == 'all'" }, { name = "atomicwrites", specifier = "==1.4.1" }, - { name = "base32-crockford", specifier = "==0.3.0" }, - { name = "blake3", specifier = ">=1.0.0" }, + { name = "base32-crockford", specifier = ">=0.3.0" }, { name = "channels", extras = ["daphne"], specifier = ">=4.1.0" }, { name = "click", specifier = ">=8.1.7" }, { name = "croniter", specifier = ">=3.0.3" }, { name = "dateparser", specifier = ">=1.2.0" }, - { name = "django", specifier = ">=5.1.4,<6.0" }, + { name = "django", specifier = ">=6.0" }, { name = "django-admin-data-views", specifier = ">=0.4.1" }, { name = "django-auth-ldap", marker = "extra == 'ldap'", specifier = ">=4.1.0" }, { name = "django-autotyping", marker = "extra == 'debug'", specifier = ">=0.5.1" }, - { name = "django-charid-field", specifier = ">=0.4" }, { name = "django-debug-toolbar", marker = "extra == 'debug'", specifier = ">=4.4.6" }, { name = "django-extensions", specifier = ">=3.2.3" }, { name = "django-huey", specifier = ">=1.2.1" }, { name = "django-huey-monitor", specifier = ">=0.9.0" }, - { name = "django-ninja", specifier = ">=1.3.0" }, + { name = "django-ninja", specifier = ">=1.5.1" }, { name = "django-object-actions", specifier = ">=4.3.0" }, { name = "django-signal-webhooks", specifier = ">=0.3.0" }, { name = "django-stubs", specifier = ">=5.0.4" }, @@ -805,7 +162,6 @@ requires-dist = [ { name = "ipython", specifier = ">=8.27.0" }, { name = "mypy-extensions", specifier = ">=1.0.0" }, { name = "platformdirs", specifier = ">=4.3.6" }, - { name = "pluggy", specifier = ">=1.5.0" }, { name = "pocket", specifier = ">=0.3.6" }, { name = "psutil", specifier = ">=6.0.0" }, { name = "py-machineid", specifier = ">=0.6.0" }, @@ -822,11 +178,11 @@ requires-dist = [ { name = "setuptools", specifier = ">=74.1.0" }, { name = "sonic-client", specifier = ">=1.0.0" }, { name = "supervisor", specifier = ">=4.2.5" }, - { name = "typeid-python", specifier = ">=0.3.1" }, { name = "tzdata", specifier = ">=2024.2" }, - { name = "ulid-py", specifier = ">=1.1.0" }, { name = "w3lib", specifier = ">=2.2.1" }, + { name = "yt-dlp", specifier = ">=2024.1.0" }, ] +provides-extras = ["sonic", "ldap", "debug", "all"] [package.metadata.requires-dev] dev = [ @@ -858,166 +214,119 @@ dev = [ [[package]] name = "asgiref" -version = "3.8.1" +version = "3.11.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/29/38/b3395cc9ad1b56d2ddac9970bc8f4141312dbaec28bc7c218b0dfafd0f42/asgiref-3.8.1.tar.gz", hash = "sha256:c343bd80a0bec947a9860adb4c432ffa7db769836c64238fc34bdc3fec84d590", size = 35186 } +sdist = { url = "https://files.pythonhosted.org/packages/76/b9/4db2509eabd14b4a8c71d1b24c8d5734c52b8560a7b1e1a8b56c8d25568b/asgiref-3.11.0.tar.gz", hash = "sha256:13acff32519542a1736223fb79a715acdebe24286d98e8b164a73085f40da2c4", size = 37969, upload-time = "2025-11-19T15:32:20.106Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/39/e3/893e8757be2612e6c266d9bb58ad2e3651524b5b40cf56761e985a28b13e/asgiref-3.8.1-py3-none-any.whl", hash = "sha256:3e1e3ecc849832fe52ccf2cb6686b7a55f82bb1d6aee72a58826471390335e47", size = 23828 }, + { url = "https://files.pythonhosted.org/packages/91/be/317c2c55b8bbec407257d45f5c8d1b6867abc76d12043f2d3d58c538a4ea/asgiref-3.11.0-py3-none-any.whl", hash = "sha256:1db9021efadb0d9512ce8ffaf72fcef601c7b73a8807a1bb2ef143dc6b14846d", size = 24096, upload-time = "2025-11-19T15:32:19.004Z" }, ] [[package]] name = "astroid" -version = "3.3.6" +version = "3.3.11" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ca/40/e028137cb19ed577001c76b91c5c50fee5a9c85099f45820b69385574ac5/astroid-3.3.6.tar.gz", hash = "sha256:6aaea045f938c735ead292204afdb977a36e989522b7833ef6fea94de743f442", size = 397452 } +sdist = { url = "https://files.pythonhosted.org/packages/18/74/dfb75f9ccd592bbedb175d4a32fc643cf569d7c218508bfbd6ea7ef9c091/astroid-3.3.11.tar.gz", hash = "sha256:1e5a5011af2920c7c67a53f65d536d65bfa7116feeaf2354d8b94f29573bb0ce", size = 400439, upload-time = "2025-07-13T18:04:23.177Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/d2/82c8ccef22ea873a2b0da9636e47d45137eeeb2fb9320c5dbbdd3627bab0/astroid-3.3.6-py3-none-any.whl", hash = "sha256:db676dc4f3ae6bfe31cda227dc60e03438378d7a896aec57422c95634e8d722f", size = 274644 }, + { url = "https://files.pythonhosted.org/packages/af/0f/3b8fdc946b4d9cc8cc1e8af42c4e409468c84441b933d037e101b3d72d86/astroid-3.3.11-py3-none-any.whl", hash = "sha256:54c760ae8322ece1abd213057c4b5bba7c49818853fc901ef09719a60dbf9dec", size = 275612, upload-time = "2025-07-13T18:04:21.07Z" }, ] [[package]] name = "asttokens" -version = "3.0.0" +version = "3.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, ] [[package]] name = "atomicwrites" version = "1.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/87/c6/53da25344e3e3a9c01095a89f16dbcda021c609ddb42dd6d7c0528236fb2/atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11", size = 14227 } +sdist = { url = "https://files.pythonhosted.org/packages/87/c6/53da25344e3e3a9c01095a89f16dbcda021c609ddb42dd6d7c0528236fb2/atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11", size = 14227, upload-time = "2022-07-08T18:31:40.459Z" } [[package]] name = "attrs" -version = "24.3.0" +version = "25.4.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 }, + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, ] [[package]] name = "autobahn" -version = "24.4.2" +version = "25.12.2" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "cbor2", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "cffi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "cryptography", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "hyperlink", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "msgpack", marker = "(platform_python_implementation == 'CPython' and sys_platform == 'darwin') or (platform_python_implementation == 'CPython' and sys_platform == 'linux')" }, + { name = "py-ubjson", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "txaio", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "u-msgpack-python", marker = "(platform_python_implementation != 'CPython' and sys_platform == 'darwin') or (platform_python_implementation != 'CPython' and sys_platform == 'linux')" }, + { name = "ujson", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/38/f2/8dffb3b709383ba5b47628b0cc4e43e8d12d59eecbddb62cfccac2e7cf6a/autobahn-24.4.2.tar.gz", hash = "sha256:a2d71ef1b0cf780b6d11f8b205fd2c7749765e65795f2ea7d823796642ee92c9", size = 482700 } +sdist = { url = "https://files.pythonhosted.org/packages/54/d5/9adf0f5b9eb244e58e898e9f3db4b00c09835ef4b6c37d491886e0376b4f/autobahn-25.12.2.tar.gz", hash = "sha256:754c06a54753aeb7e8d10c5cbf03249ad9e2a1a32bca8be02865c6f00628a98c", size = 13893652, upload-time = "2025-12-15T11:13:19.086Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/13/ee/a6475f39ef6c6f41c33da6b193e0ffd2c6048f52e1698be6253c59301b72/autobahn-24.4.2-py2.py3-none-any.whl", hash = "sha256:c56a2abe7ac78abbfb778c02892d673a4de58fd004d088cd7ab297db25918e81", size = 666965 }, + { url = "https://files.pythonhosted.org/packages/54/b7/0a0e3ecb2af7e452f5f359d19bdc647cbc8658f3f498bfa3bf8545cf4768/autobahn-25.12.2-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c840ee136bfaf6560467160129b0b25a0e33c9a51e2b251e98c5474f27583915", size = 1960463, upload-time = "2025-12-15T11:13:10.183Z" }, + { url = "https://files.pythonhosted.org/packages/19/8b/4215ac49d6b793b592fb08698f3a0e21a59eb3520be7f7ed288fcb52d919/autobahn-25.12.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9abda5cf817c0f8a19a55a67a031adf2fc70ed351719b5bd9e6fa0f5f4bc8f89", size = 2225590, upload-time = "2025-12-15T11:13:11.367Z" }, ] [[package]] name = "automat" -version = "24.8.1" +version = "25.4.16" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8d/2d/ede4ad7fc34ab4482389fa3369d304f2fa22e50770af706678f6a332fa82/automat-24.8.1.tar.gz", hash = "sha256:b34227cf63f6325b8ad2399ede780675083e439b20c323d376373d8ee6306d88", size = 128679 } +sdist = { url = "https://files.pythonhosted.org/packages/e3/0f/d40bbe294bbf004d436a8bcbcfaadca8b5140d39ad0ad3d73d1a8ba15f14/automat-25.4.16.tar.gz", hash = "sha256:0017591a5477066e90d26b0e696ddc143baafd87b588cfac8100bc6be9634de0", size = 129977, upload-time = "2025-04-16T20:12:16.002Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/af/cc/55a32a2c98022d88812b5986d2a92c4ff3ee087e83b712ebc703bba452bf/Automat-24.8.1-py3-none-any.whl", hash = "sha256:bf029a7bc3da1e2c24da2343e7598affaa9f10bf0ab63ff808566ce90551e02a", size = 42585 }, + { url = "https://files.pythonhosted.org/packages/02/ff/1175b0b7371e46244032d43a56862d0af455823b5280a50c63d99cc50f18/automat-25.4.16-py3-none-any.whl", hash = "sha256:04e9bce696a8d5671ee698005af6e5a9fa15354140a87f4870744604dcdd3ba1", size = 42842, upload-time = "2025-04-16T20:12:14.447Z" }, ] [[package]] name = "babel" -version = "2.16.0" +version = "2.17.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2a/74/f1bc80f23eeba13393b7222b11d95ca3af2c1e28edca18af487137eefed9/babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316", size = 9348104 } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", size = 9587599 }, + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, ] [[package]] name = "base32-crockford" version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a8/e7/868d9b106ffb86ebf1eb877517e03ac87667ce5ce201547fa3a26090c1ba/base32-crockford-0.3.0.tar.gz", hash = "sha256:115f5bd32ae32b724035cb02eb65069a8824ea08c08851eb80c8b9f63443a969", size = 4538 } +sdist = { url = "https://files.pythonhosted.org/packages/a8/e7/868d9b106ffb86ebf1eb877517e03ac87667ce5ce201547fa3a26090c1ba/base32-crockford-0.3.0.tar.gz", hash = "sha256:115f5bd32ae32b724035cb02eb65069a8824ea08c08851eb80c8b9f63443a969", size = 4538, upload-time = "2015-03-19T22:00:21.687Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/6f/7ad1176c56c920e9841b14923f81545a4243876628312f143915561770d2/base32_crockford-0.3.0-py2.py3-none-any.whl", hash = "sha256:295ef5ffbf6ed96b6e739ffd36be98fa7e90a206dd18c39acefb15777eedfe6e", size = 5050 }, + { url = "https://files.pythonhosted.org/packages/4d/6f/7ad1176c56c920e9841b14923f81545a4243876628312f143915561770d2/base32_crockford-0.3.0-py2.py3-none-any.whl", hash = "sha256:295ef5ffbf6ed96b6e739ffd36be98fa7e90a206dd18c39acefb15777eedfe6e", size = 5050, upload-time = "2015-03-19T22:00:34.116Z" }, ] [[package]] name = "beautifulsoup4" -version = "4.12.3" +version = "4.14.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "soupsieve", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b3/ca/824b1195773ce6166d388573fc106ce56d4a805bd7427b624e063596ec58/beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051", size = 581181 } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/fe/e8c672695b37eecc5cbf43e1d0638d88d66ba3a44c4d321c796f4e59167f/beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed", size = 147925 }, -] - -[[package]] -name = "blake3" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7a/44/b1fe350288c3c1a80f8550c442a5f31b5c41bb13306b35a8ffa0006983c2/blake3-1.0.0.tar.gz", hash = "sha256:c117163d3bb9f65c2e78e04bbcab9b48d704f6106436a1dd6561f0e371610373", size = 114577 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/36/8a/4918f300afdc4804cc7123749469ff57e44aa46524aef8288e2b45dd8236/blake3-1.0.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:4e7031327f790fe322719a3644735cd8f71c166bb69f14b1bb8c6d3a377b077e", size = 330927 }, - { url = "https://files.pythonhosted.org/packages/cf/ce/166af8bd2ee99ed8f8fdc8228d31f40f8e6920b86f0ec90a5f00e80fdca2/blake3-1.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6856376a66bcb23d9350da98df42a8fe6581c56f84b21255202360b14c2cc96d", size = 311354 }, - { url = "https://files.pythonhosted.org/packages/1a/9c/bf926c668066ab3875d2ac588d1c29424324303aad9138f6476370753348/blake3-1.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbd439f7504b85cd5af09f76ee5b8fad2ab880e423dc8b6a3757843619a129d6", size = 354724 }, - { url = "https://files.pythonhosted.org/packages/4d/d7/46c93835a27752f71ab31d477995b357c82131b2f41459190c57814acbcd/blake3-1.0.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:132b6614e902d0ef5eed29170cbe72af40b87e1d8a874bca3da5ad1cdfba7a3c", size = 356879 }, - { url = "https://files.pythonhosted.org/packages/00/86/3eb9c589a9516b5243ad3614b4327d351655be2937e463d75ad7c9629a17/blake3-1.0.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0369841b46dcbb44718fa4f13e16346611df03a34102adfebc42ec8e448f3b16", size = 428097 }, - { url = "https://files.pythonhosted.org/packages/b3/c6/a64d18bc978ebed42e0b91ac668842f8d4b1ec02a2e27883745f9a0a8c11/blake3-1.0.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:43a2daf3d202eb5c1f0d6f153c9efb52fc263879b97c364c690db48ab39b11ef", size = 397419 }, - { url = "https://files.pythonhosted.org/packages/7b/72/19b2c3590c7aebc1828dbda869d2f8425e180180b82b92288cd8b3fd1019/blake3-1.0.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:925069543355a3beabb8051467800cc289c4e5758b7176314192d93adf5560f3", size = 393047 }, - { url = "https://files.pythonhosted.org/packages/c8/07/6ccdabbc5a80883608287aef2f32ce8adf2e815a08c42ee9e85cfb58d1dd/blake3-1.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdbf770b3a74cbfa750179e751a16a991caa16667abd19557b63fd63bae014f9", size = 367286 }, - { url = "https://files.pythonhosted.org/packages/fc/f1/b0ed6f8ef54bce1b80e9bad069edc2e364cfacd686d9f3c1f8953b8171fb/blake3-1.0.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7261be350a9b9b0bc7f329a2d34c19da54fac7d635f5c1f28319b127cb36404b", size = 529180 }, - { url = "https://files.pythonhosted.org/packages/2e/b8/0348668d8b42bfadc1b28f1b82700cc959b42386ea2b96106faef07b2f27/blake3-1.0.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:719845a02d15262e5aaba0aebc3c896d6dc0550be9ee9bcfd521954dee325422", size = 536936 }, - { url = "https://files.pythonhosted.org/packages/d0/34/a109f094106e6a7e620b1e1921ab6c3ddf85d6562f27de2c1500c1cdccc9/blake3-1.0.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:54c2a14107b35e68e4b0660c7b640a23529f3fa13c9138baa7e2255e199aaac9", size = 330924 }, - { url = "https://files.pythonhosted.org/packages/0f/6e/442a07c45d83f80adc95b86ae202a0b9800815f772a58335e9f168dd2299/blake3-1.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d0ebea0a25c4420d594ad27692a28044d0133af201dd004488ac68008b4069dd", size = 311351 }, - { url = "https://files.pythonhosted.org/packages/10/8f/917fcdb17098b1e3401f8441639139cb499b0f7c35864a5f02060952ecef/blake3-1.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4922e54b986526ad9160aa6fad68a71ecc3ac76e7e6fc51e50e2cb107701b5ae", size = 354725 }, - { url = "https://files.pythonhosted.org/packages/07/68/b760d6a128063d83760b53b549d09c008ccb8eeb7e3fff816fd4b1c5d7b4/blake3-1.0.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d0e73ee20a303257239dc337c24a36630c9130d9f1c2d2f390c6c965f325b829", size = 356878 }, - { url = "https://files.pythonhosted.org/packages/a8/7f/48cd153605a3bd2dde0af2d2199905dbc34e1c12ff2957211409bb64fd16/blake3-1.0.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:33605483cfdb320dee9a508ae2290c6e5e5f2c1c4174f745d37ea7eab2c6f9a0", size = 428098 }, - { url = "https://files.pythonhosted.org/packages/34/94/0552abda548aae27f2238c5866458b0c9cee584a82e95ddc18e162d65ca6/blake3-1.0.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3d1e994e443be71a930de655638a3339cd0c97bdc3a5bec2b60d6a8728478b0e", size = 397421 }, - { url = "https://files.pythonhosted.org/packages/3e/32/39abede3f96cdf59f459f3093b0388b67a882f4c531a689ff20b857cdc4c/blake3-1.0.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:608d433777f71422fea74f0f451c2b31ac8440ab5211ddb309d647537f16e28c", size = 393047 }, - { url = "https://files.pythonhosted.org/packages/53/04/cc44b2bd1a77eb575af8641532891db5863b30793243442f76bd043dcf9e/blake3-1.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e66f2f0693909d20d66bd60557fdcf607e46286d5bb2d4ea05cce62f9a155ada", size = 367286 }, - { url = "https://files.pythonhosted.org/packages/b8/07/229b64ef003436f969926ab1f2305ae756d28e9f285cf5def4d7dcd582b5/blake3-1.0.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e3fa4560ce1382a555011ccfbdda5bc93668f2fd757b9fd4833f5a9e3eccbb31", size = 529184 }, - { url = "https://files.pythonhosted.org/packages/9f/34/37b759fbb94aa2153c193d95890aaa524d583cfd7b9a86dc4bcd5fccb86e/blake3-1.0.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7e767be72b24cfa0d0791907cfa7dd984b2c7dd2cbe131f4fb23280dc494280c", size = 536937 }, - { url = "https://files.pythonhosted.org/packages/a7/dc/4689ec2c1340c31ee7c35af90617c47d8581e3477819504d5a9b6400427e/blake3-1.0.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f6ac72ad4581f027f3f8cc6468c2f448d3e66dd16f28f2292abe029fc6b3c619", size = 330926 }, - { url = "https://files.pythonhosted.org/packages/21/b8/018593861dab3b0f7ca373401bb4bccd7c4be1cff761bfb68ca4c31019f8/blake3-1.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6391bdd1aa6bf2c7d0907cb53d5f8f833848946cada9c84b518f5d040de1c1d8", size = 311353 }, - { url = "https://files.pythonhosted.org/packages/83/fc/67bece25319a2f0ce79f8cc39e81bb9577d70c991c2c269dd3269b119b26/blake3-1.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bacd471314c88704ab693825b34671de742c2798872f3160096d811357c2d3a3", size = 354725 }, - { url = "https://files.pythonhosted.org/packages/68/fb/49010974d0db1b79f0721870978098f17422c7c194929f86cfe374a1ecb4/blake3-1.0.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f87cbe72f414c52c77581e2d5be30c06f86d7dd47952341381ea02fa12411fa6", size = 356878 }, - { url = "https://files.pythonhosted.org/packages/1f/10/d7c95516c300f820a25d7bd73b15da35f3e787b127896fb7b3f0782bc59c/blake3-1.0.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80ca6ed8af3e2fd3fa711283f247da52610281db42c985855d7d700ced08bfaa", size = 428096 }, - { url = "https://files.pythonhosted.org/packages/de/a3/df55a169470487457d2e260fc8b7bb9b526332c91448e4768b5d6ff77cf5/blake3-1.0.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6905c374a1b6569bef88e4eaf5b6d3a81313f7e944d7c819bd8d22ba8a42b4c7", size = 397418 }, - { url = "https://files.pythonhosted.org/packages/67/47/4ea7cd0509a59449e4a98fc5c4d26e0fff5423778aae5d33bc95226c6568/blake3-1.0.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:795e18f8f07990c7e736c81b697c3876c57b71745193761a049950f544c0f4bf", size = 393048 }, - { url = "https://files.pythonhosted.org/packages/44/ca/1657cffc9c6ba170ff6bb927b20f281e64827e2a7235ec5fa7e4e307d002/blake3-1.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a7cdf1a24090267dc6c4ab752981a529c68cffbb641dc9f793debfd22ebe32f", size = 367285 }, - { url = "https://files.pythonhosted.org/packages/58/6f/ea24308534d4a8f5c0786f1b671480c52f736f48a91bb2d28f35f5657753/blake3-1.0.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ca493629407e4a7c7c4b823f59e7d79c2142f0395169f39630e9a2bf66b7890f", size = 529184 }, - { url = "https://files.pythonhosted.org/packages/fc/56/f01c9602e4d98e96a76bc952860786218ca44b283c92b12d56943536332a/blake3-1.0.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8c19a17f343f5a462f73089098208a0210db0a6aa0272b42025a79b71558c55f", size = 536937 }, - { url = "https://files.pythonhosted.org/packages/04/68/036f47412e8c294011d0ed9eb27e57d018ed43810c80fffc31b39843521d/blake3-1.0.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5b0fc061cee3d27672baa3526217747a0b91c728e8eb2235cfc9c94ce77e6cb8", size = 330924 }, - { url = "https://files.pythonhosted.org/packages/33/3d/f3e6a3ced4263015170a9421343884da642d2238155611506b431a6f7cec/blake3-1.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:109e8dda9c017c4d8ebc0f3e28c0586b793789b0a0b49e46f8f46b268afa04c9", size = 311356 }, - { url = "https://files.pythonhosted.org/packages/2d/3e/7c961d3a38c54959b23fc0ae4b61f76312a37514c0c3c28211eca49c3a08/blake3-1.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d16739031ae34dc2e377b0a6c689ed0bdade937d125159c1d037ce3609860760", size = 354726 }, - { url = "https://files.pythonhosted.org/packages/a1/5f/95bcfaec261ccd6ae6fb719e9ce4784b11571f13cd5f0378c1d9a020405d/blake3-1.0.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5977bd858d59e693f21ad5ed82776356df6f1d3b5b557a8fd5a918a994d71a21", size = 356881 }, - { url = "https://files.pythonhosted.org/packages/81/c1/7e697e7fc38c45e0fc411b6bb4f562a1c1a9d52dc5d434c849bdcdaf8e41/blake3-1.0.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12f5a7f52ea325026df06b6df030fc9f79f7bc23c8745c9161491ac1a0148988", size = 428097 }, - { url = "https://files.pythonhosted.org/packages/a4/94/dc6c1e808e22e34d140c8c1bc02651ebee3939d5e365687c70165f0c9343/blake3-1.0.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76f45368fb0188f9856d6354baa0370058cbfb420b0579fa49bac54cd8a690a2", size = 397419 }, - { url = "https://files.pythonhosted.org/packages/1c/10/bd68137769e50152575af90e0143e60acc12743bcd2472487875aecb07b5/blake3-1.0.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b00c1703c593e52cccff5350a5deae9ce009d27fd906e3f35eafe3e38e8eabf", size = 393045 }, - { url = "https://files.pythonhosted.org/packages/9b/52/4c2984bdfd28ede365d7e42cc4c00b6445ed7043a93f63bb78e231f2f405/blake3-1.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f456be40166f4cd8bc2bf4eaaf10a506a21c8522e138123d4693dceca150c88d", size = 367285 }, - { url = "https://files.pythonhosted.org/packages/e5/13/7307af1c68f5bfcc691109df5090944a29cb9079cabb8e74461938ba2a98/blake3-1.0.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0852050db645ce4f6b7580ffabb8efea77b33fd7a9eeaa0085d8220901f5cf3e", size = 529183 }, - { url = "https://files.pythonhosted.org/packages/21/27/4d7ce635ff6cfea69d7b6378091926229ae6634aa22ea5e7e1d1b5c31684/blake3-1.0.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:534c6aab66afe23a03888b0f187e3827c646fd169469ef4039a3f2c210ab8f3e", size = 536938 }, + { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, ] [[package]] name = "bottle" -version = "0.13.2" +version = "0.13.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/97839b95c2a2ea1ca91877a846988f90f4ca16ee42c0bb79e079171c0c06/bottle-0.13.2.tar.gz", hash = "sha256:e53803b9d298c7d343d00ba7d27b0059415f04b9f6f40b8d58b5bf914ba9d348", size = 98472 } +sdist = { url = "https://files.pythonhosted.org/packages/7a/71/cca6167c06d00c81375fd668719df245864076d284f7cb46a694cbeb5454/bottle-0.13.4.tar.gz", hash = "sha256:787e78327e12b227938de02248333d788cfe45987edca735f8f88e03472c3f47", size = 98717, upload-time = "2025-06-15T10:08:59.439Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/0a/a5260c758ff813acc6967344339aa7ba15f815575f4d49141685c4345d39/bottle-0.13.2-py2.py3-none-any.whl", hash = "sha256:27569ab8d1332fbba3e400b3baab2227ab4efb4882ff147af05a7c00ed73409c", size = 104053 }, + { url = "https://files.pythonhosted.org/packages/83/f6/b55ec74cfe68c6584163faa311503c20b0da4c09883a41e8e00d6726c954/bottle-0.13.4-py2.py3-none-any.whl", hash = "sha256:045684fbd2764eac9cdeb824861d1551d113e8b683d8d26e296898d3dd99a12e", size = 103807, upload-time = "2025-06-15T10:08:57.691Z" }, ] [[package]] name = "bumpver" -version = "2024.1130" +version = "2025.1131" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -1025,103 +334,96 @@ dependencies = [ { name = "lexid", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "toml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bb/a9/becf78cc86211bd2287114c4f990a3bed450816696f14810cc59d7815bb5/bumpver-2024.1130.tar.gz", hash = "sha256:74f7ebc294b2240f346e99748cc6f238e57b050999d7428db75d76baf2bf1437", size = 115102 } +sdist = { url = "https://files.pythonhosted.org/packages/8f/8a/cc13e816e9f0849dce423b904b06fd91b5444cba6df3200d512a702f2e95/bumpver-2025.1131.tar.gz", hash = "sha256:a35fd2d43a5f65f014035c094866bd3bd6c739606f29fd41246d6ec6e839d3f9", size = 115372, upload-time = "2025-07-02T20:36:11.982Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/34/57d038ae30374976ce4ec57db9dea95bf55d1b5543b35e77aa9ce3543198/bumpver-2024.1130-py2.py3-none-any.whl", hash = "sha256:8e54220aefe7db25148622f45959f7beb6b8513af0b0429b38b9072566665a49", size = 65273 }, + { url = "https://files.pythonhosted.org/packages/1d/5b/2d5ea6802495ee4506721977be522804314aa66ad629d9356e3c7e5af4a6/bumpver-2025.1131-py2.py3-none-any.whl", hash = "sha256:c02527f6ed7887afbc06c07630047b24a9f9d02d544a65639e99bf8b92aaa674", size = 65361, upload-time = "2025-07-02T20:36:10.103Z" }, ] [[package]] name = "bx-django-utils" -version = "84" +version = "91" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "bx-py-utils", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "python-stdnum", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e9/ee/4dda2fe8c97203eda3d3a702af7af2972d130e77ad6077a4d26dc42e32f2/bx_django_utils-84.tar.gz", hash = "sha256:665d39455ffdb00b6df2948f75f13b379d249b2a5c5a93ccee2f23c5a9c162c2", size = 193256 } +sdist = { url = "https://files.pythonhosted.org/packages/f3/fd/8d22d436734f85ac908129c5f5b5440c27abcbfaf62c2c0b2dfdd9fab142/bx_django_utils-91.tar.gz", hash = "sha256:289b478aaa864f1a396a1e0c287654868aa2f4ebe5b8fd9deddd813f7f5b054d", size = 215586, upload-time = "2025-09-16T06:45:54.31Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/5a/0b5667455ee420e130e43dcfb579882a34f136e344dbb0e61e3e0af85ff0/bx_django_utils-84-py3-none-any.whl", hash = "sha256:e42081f04e40e4f273cc539e287348b093654bbc872de25d66b14f431d453eec", size = 202796 }, + { url = "https://files.pythonhosted.org/packages/89/1e/324f4fb8466dded45256306765786a2ac8a9465976b2b954d45212e540a2/bx_django_utils-91-py3-none-any.whl", hash = "sha256:9b4ff1aefe99e84800996ccfbaf85d7fe66dcd1bc929900bd1f81968683c17a1", size = 118196, upload-time = "2025-09-16T06:45:52.485Z" }, ] [[package]] name = "bx-py-utils" -version = "106" +version = "114" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/07/97/25d9c34122d4d9a33383c8b265a0bd9f5391f18a7ae9aa65c61877941649/bx_py_utils-106.tar.gz", hash = "sha256:26d6d3353ccd7d93ae322d33f8dde1b14d01b88f10329a714cd43da67b2e3d9f", size = 192712 } +sdist = { url = "https://files.pythonhosted.org/packages/39/d2/8b2bcaa1efa89f78afdd200f102b76753a7472190914e010420349502eab/bx_py_utils-114.tar.gz", hash = "sha256:193c19781c5e9c3decaf26b80b0fa67e8419cb0640848b12b791c3e4a1a4c9a2", size = 235491, upload-time = "2025-11-28T09:54:07.919Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/75/297e15764b5e46259ef68ed3deef98413a3ae038512a468e36623b41d13e/bx_py_utils-106-py3-none-any.whl", hash = "sha256:1b5e7622310c5ef814de241419bc0f0929c3d0445e1418fa477d2be3f7da0332", size = 176056 }, + { url = "https://files.pythonhosted.org/packages/d6/d2/00464fcd8ab77f2426bc7b16f2742164d404f78727b596dc822be1ca7873/bx_py_utils-114-py3-none-any.whl", hash = "sha256:0b77849a106ff72d47f793fdb436f2c569a8946ef3e32ce57f02e24625e0b059", size = 59605, upload-time = "2025-11-28T09:54:06.56Z" }, +] + +[[package]] +name = "cbor2" +version = "5.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/b8/c0f6a7d46f816cb18b1fda61a2fe648abe16039f1ff93ea720a6e9fb3cee/cbor2-5.7.1.tar.gz", hash = "sha256:7a405a1d7c8230ee9acf240aad48ae947ef584e8af05f169f3c1bde8f01f8b71", size = 102467, upload-time = "2025-10-24T09:23:06.569Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/f0/f220222a57371e33434ba7bdc25de31d611cbc0ade2a868e03c3553305e7/cbor2-5.7.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e5826e4fa4c33661960073f99cf67c82783895524fb66f3ebdd635c19b5a7d68", size = 69002, upload-time = "2025-10-24T09:22:44.316Z" }, + { url = "https://files.pythonhosted.org/packages/c7/3c/34b62ba5173541659f248f005d13373530f02fb997b78fde00bf01ede4f4/cbor2-5.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f19a00d6ac9a77cb611073250b06bf4494b41ba78a1716704f7008e0927d9366", size = 69177, upload-time = "2025-10-24T09:22:45.711Z" }, + { url = "https://files.pythonhosted.org/packages/77/fd/2400d820d9733df00a5c18aa74201e51d710fb91588687eb594f4a7688ea/cbor2-5.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2113aea044cd172f199da3520bc4401af69eae96c5180ca7eb660941928cb89", size = 284259, upload-time = "2025-10-24T09:22:46.749Z" }, + { url = "https://files.pythonhosted.org/packages/42/65/280488ef196c1d71ba123cd406ea47727bb3a0e057767a733d9793fcc428/cbor2-5.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f17eacea2d28fecf28ac413c1d7927cde0a11957487d2630655d6b5c9c46a0b", size = 281958, upload-time = "2025-10-24T09:22:48.876Z" }, + { url = "https://files.pythonhosted.org/packages/42/82/bcdd3fdc73bd5f4194fdb08c808112010add9530bae1dcfdb1e2b2ceae19/cbor2-5.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d65deea39cae533a629561e7da672402c46731122b6129ed7c8eaa1efe04efce", size = 276025, upload-time = "2025-10-24T09:22:50.147Z" }, + { url = "https://files.pythonhosted.org/packages/ae/a8/a6065dd6a157b877d7d8f3fe96f410fb191a2db1e6588f4d20b5f9a507c2/cbor2-5.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:57d8cc29ec1fd20500748e0e767ff88c13afcee839081ba4478c41fcda6ee18b", size = 275978, upload-time = "2025-10-24T09:22:51.873Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/383bafeabb54c17fe5b6d5aca4e863e6b7df10bcc833b34aa169e9dfce1a/cbor2-5.7.1-py3-none-any.whl", hash = "sha256:68834e4eff2f56629ce6422b0634bc3f74c5a4269de5363f5265fe452c706ba7", size = 23829, upload-time = "2025-10-24T09:23:05.54Z" }, ] [[package]] name = "certifi" -version = "2024.12.14" +version = "2025.11.12" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010 } +sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927 }, + { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" }, ] [[package]] name = "cffi" -version = "1.17.1" +version = "2.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pycparser", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "pycparser", marker = "(implementation_name != 'PyPy' and sys_platform == 'darwin') or (implementation_name != 'PyPy' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 }, - { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 }, - { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 }, - { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 }, - { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 }, - { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 }, - { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 }, - { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 }, - { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 }, - { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, - { 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 }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, ] [[package]] name = "channels" -version = "4.2.0" +version = "4.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/96/e2/10d949dca9eb8a85c5735efefe3309033419e7d4f4193a70f6ede58b2951/channels-4.2.0.tar.gz", hash = "sha256:d9e707487431ba5dbce9af982970dab3b0efd786580fadb99e45dca5e39fdd59", size = 26554 } +sdist = { url = "https://files.pythonhosted.org/packages/74/92/b18d4bb54d14986a8b35215a1c9e6a7f9f4d57ca63ac9aee8290ebb4957d/channels-4.3.2.tar.gz", hash = "sha256:f2bb6bfb73ad7fb4705041d07613c7b4e69528f01ef8cb9fb6c21d9295f15667", size = 27023, upload-time = "2025-11-20T15:13:05.102Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/4e/f36a0e2c04504014385cbc13119a15b8a716e524e8e5ed9480581397691a/channels-4.2.0-py3-none-any.whl", hash = "sha256:6b75bc8d6888fb7236e7e7bf1948520b72d296ad08216a242fc56b1db0ffde1a", size = 30935 }, + { url = "https://files.pythonhosted.org/packages/16/34/c32915288b7ef482377b6adc401192f98c6a99b3a145423d3b8aed807898/channels-4.3.2-py3-none-any.whl", hash = "sha256:fef47e9055a603900cf16cef85f050d522d9ac4b3daccf24835bd9580705c176", size = 31313, upload-time = "2025-11-20T15:13:02.357Z" }, ] [package.optional-dependencies] @@ -1131,99 +433,60 @@ daphne = [ [[package]] name = "charset-normalizer" -version = "3.4.0" +version = "3.4.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/69/8b/825cc84cf13a28bfbcba7c416ec22bf85a9584971be15b21dd8300c65b7f/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6", size = 196363 }, - { url = "https://files.pythonhosted.org/packages/23/81/d7eef6a99e42c77f444fdd7bc894b0ceca6c3a95c51239e74a722039521c/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b", size = 125639 }, - { url = "https://files.pythonhosted.org/packages/21/67/b4564d81f48042f520c948abac7079356e94b30cb8ffb22e747532cf469d/charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99", size = 120451 }, - { url = "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca", size = 140041 }, - { url = "https://files.pythonhosted.org/packages/67/56/fa28c2c3e31217c4c52158537a2cf5d98a6c1e89d31faf476c89391cd16b/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d", size = 150333 }, - { url = "https://files.pythonhosted.org/packages/f9/d2/466a9be1f32d89eb1554cf84073a5ed9262047acee1ab39cbaefc19635d2/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7", size = 142921 }, - { url = "https://files.pythonhosted.org/packages/f8/01/344ec40cf5d85c1da3c1f57566c59e0c9b56bcc5566c08804a95a6cc8257/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3", size = 144785 }, - { url = "https://files.pythonhosted.org/packages/73/8b/2102692cb6d7e9f03b9a33a710e0164cadfce312872e3efc7cfe22ed26b4/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907", size = 146631 }, - { url = "https://files.pythonhosted.org/packages/d8/96/cc2c1b5d994119ce9f088a9a0c3ebd489d360a2eb058e2c8049f27092847/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b", size = 140867 }, - { url = "https://files.pythonhosted.org/packages/c9/27/cde291783715b8ec30a61c810d0120411844bc4c23b50189b81188b273db/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912", size = 149273 }, - { url = "https://files.pythonhosted.org/packages/3a/a4/8633b0fc1a2d1834d5393dafecce4a1cc56727bfd82b4dc18fc92f0d3cc3/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95", size = 152437 }, - { url = "https://files.pythonhosted.org/packages/64/ea/69af161062166b5975ccbb0961fd2384853190c70786f288684490913bf5/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e", size = 150087 }, - { url = "https://files.pythonhosted.org/packages/3b/fd/e60a9d9fd967f4ad5a92810138192f825d77b4fa2a557990fd575a47695b/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe", size = 145142 }, - { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 }, - { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 }, - { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 }, - { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 }, - { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 }, - { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 }, - { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 }, - { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 }, - { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 }, - { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 }, - { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 }, - { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 }, - { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 }, - { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 }, - { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 }, - { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 }, - { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 }, - { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 }, - { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 }, - { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 }, - { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 }, - { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 }, - { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 }, - { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 }, - { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 }, - { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 }, - { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 }, - { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 }, - { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 }, - { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 }, - { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 }, - { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 }, - { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 }, - { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 }, - { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 }, - { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 }, - { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 }, - { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 }, - { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 }, - { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, ] [[package]] name = "click" -version = "8.1.7" +version = "8.3.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 } +sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 }, + { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, ] [[package]] name = "colorama" version = "0.4.6" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] [[package]] name = "commonmark" version = "0.9.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/60/48/a60f593447e8f0894ebb7f6e6c1f25dafc5e89c5879fdc9360ae93ff83f0/commonmark-0.9.1.tar.gz", hash = "sha256:452f9dc859be7f06631ddcb328b6919c67984aca654e5fefb3914d54691aed60", size = 95764 } +sdist = { url = "https://files.pythonhosted.org/packages/60/48/a60f593447e8f0894ebb7f6e6c1f25dafc5e89c5879fdc9360ae93ff83f0/commonmark-0.9.1.tar.gz", hash = "sha256:452f9dc859be7f06631ddcb328b6919c67984aca654e5fefb3914d54691aed60", size = 95764, upload-time = "2019-10-04T15:37:39.817Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/92/dfd892312d822f36c55366118b95d914e5f16de11044a27cf10a7d71bbbf/commonmark-0.9.1-py2.py3-none-any.whl", hash = "sha256:da2f38c92590f83de410ba1a3cbceafbc74fee9def35f9251ba9a971d6d66fd9", size = 51068 }, + { url = "https://files.pythonhosted.org/packages/b1/92/dfd892312d822f36c55366118b95d914e5f16de11044a27cf10a7d71bbbf/commonmark-0.9.1-py2.py3-none-any.whl", hash = "sha256:da2f38c92590f83de410ba1a3cbceafbc74fee9def35f9251ba9a971d6d66fd9", size = 51068, upload-time = "2019-10-04T15:37:37.674Z" }, ] [[package]] name = "constantly" version = "23.10.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4d/6f/cb2a94494ff74aa9528a36c5b1422756330a75a8367bf20bd63171fc324d/constantly-23.10.4.tar.gz", hash = "sha256:aa92b70a33e2ac0bb33cd745eb61776594dc48764b06c35e0efd050b7f1c7cbd", size = 13300 } +sdist = { url = "https://files.pythonhosted.org/packages/4d/6f/cb2a94494ff74aa9528a36c5b1422756330a75a8367bf20bd63171fc324d/constantly-23.10.4.tar.gz", hash = "sha256:aa92b70a33e2ac0bb33cd745eb61776594dc48764b06c35e0efd050b7f1c7cbd", size = 13300, upload-time = "2023-10-28T23:18:24.316Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/40/c199d095151addf69efdb4b9ca3a4f20f70e20508d6222bffb9b76f58573/constantly-23.10.4-py3-none-any.whl", hash = "sha256:3fd9b4d1c3dc1ec9757f3c52aef7e53ad9323dbe39f51dfd4c43853b68dfa3f9", size = 13547 }, + { url = "https://files.pythonhosted.org/packages/b8/40/c199d095151addf69efdb4b9ca3a4f20f70e20508d6222bffb9b76f58573/constantly-23.10.4-py3-none-any.whl", hash = "sha256:3fd9b4d1c3dc1ec9757f3c52aef7e53ad9323dbe39f51dfd4c43853b68dfa3f9", size = 13547, upload-time = "2023-10-28T23:18:23.038Z" }, ] [[package]] @@ -1234,60 +497,75 @@ dependencies = [ { name = "python-dateutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pytz", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ad/2f/44d1ae153a0e27be56be43465e5cb39b9650c781e001e7864389deb25090/croniter-6.0.0.tar.gz", hash = "sha256:37c504b313956114a983ece2c2b07790b1f1094fe9d81cc94739214748255577", size = 64481 } +sdist = { url = "https://files.pythonhosted.org/packages/ad/2f/44d1ae153a0e27be56be43465e5cb39b9650c781e001e7864389deb25090/croniter-6.0.0.tar.gz", hash = "sha256:37c504b313956114a983ece2c2b07790b1f1094fe9d81cc94739214748255577", size = 64481, upload-time = "2024-12-17T17:17:47.32Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/07/4b/290b4c3efd6417a8b0c284896de19b1d5855e6dbdb97d2a35e68fa42de85/croniter-6.0.0-py2.py3-none-any.whl", hash = "sha256:2f878c3856f17896979b2a4379ba1f09c83e374931ea15cc835c5dd2eee9b368", size = 25468 }, + { url = "https://files.pythonhosted.org/packages/07/4b/290b4c3efd6417a8b0c284896de19b1d5855e6dbdb97d2a35e68fa42de85/croniter-6.0.0-py2.py3-none-any.whl", hash = "sha256:2f878c3856f17896979b2a4379ba1f09c83e374931ea15cc835c5dd2eee9b368", size = 25468, upload-time = "2024-12-17T17:17:45.359Z" }, ] [[package]] name = "cryptography" -version = "44.0.0" +version = "46.0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cffi", marker = "(platform_python_implementation != 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/91/4c/45dfa6829acffa344e3967d6006ee4ae8be57af746ae2eba1c431949b32c/cryptography-44.0.0.tar.gz", hash = "sha256:cd4e834f340b4293430701e772ec543b0fbe6c2dea510a5286fe0acabe153a02", size = 710657 } +sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/55/09/8cc67f9b84730ad330b3b72cf867150744bf07ff113cda21a15a1c6d2c7c/cryptography-44.0.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:84111ad4ff3f6253820e6d3e58be2cc2a00adb29335d4cacb5ab4d4d34f2a123", size = 6541833 }, - { url = "https://files.pythonhosted.org/packages/7e/5b/3759e30a103144e29632e7cb72aec28cedc79e514b2ea8896bb17163c19b/cryptography-44.0.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15492a11f9e1b62ba9d73c210e2416724633167de94607ec6069ef724fad092", size = 3922710 }, - { url = "https://files.pythonhosted.org/packages/5f/58/3b14bf39f1a0cfd679e753e8647ada56cddbf5acebffe7db90e184c76168/cryptography-44.0.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:831c3c4d0774e488fdc83a1923b49b9957d33287de923d58ebd3cec47a0ae43f", size = 4137546 }, - { url = "https://files.pythonhosted.org/packages/98/65/13d9e76ca19b0ba5603d71ac8424b5694415b348e719db277b5edc985ff5/cryptography-44.0.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:761817a3377ef15ac23cd7834715081791d4ec77f9297ee694ca1ee9c2c7e5eb", size = 3915420 }, - { url = "https://files.pythonhosted.org/packages/b1/07/40fe09ce96b91fc9276a9ad272832ead0fddedcba87f1190372af8e3039c/cryptography-44.0.0-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3c672a53c0fb4725a29c303be906d3c1fa99c32f58abe008a82705f9ee96f40b", size = 4154498 }, - { url = "https://files.pythonhosted.org/packages/75/ea/af65619c800ec0a7e4034207aec543acdf248d9bffba0533342d1bd435e1/cryptography-44.0.0-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:4ac4c9f37eba52cb6fbeaf5b59c152ea976726b865bd4cf87883a7e7006cc543", size = 3932569 }, - { url = "https://files.pythonhosted.org/packages/c7/af/d1deb0c04d59612e3d5e54203159e284d3e7a6921e565bb0eeb6269bdd8a/cryptography-44.0.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ed3534eb1090483c96178fcb0f8893719d96d5274dfde98aa6add34614e97c8e", size = 4016721 }, - { url = "https://files.pythonhosted.org/packages/bd/69/7ca326c55698d0688db867795134bdfac87136b80ef373aaa42b225d6dd5/cryptography-44.0.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f3f6fdfa89ee2d9d496e2c087cebef9d4fcbb0ad63c40e821b39f74bf48d9c5e", size = 4240915 }, - { url = "https://files.pythonhosted.org/packages/11/18/61e52a3d28fc1514a43b0ac291177acd1b4de00e9301aaf7ef867076ff8a/cryptography-44.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:660cb7312a08bc38be15b696462fa7cc7cd85c3ed9c576e81f4dc4d8b2b31591", size = 6542801 }, - { url = "https://files.pythonhosted.org/packages/1a/07/5f165b6c65696ef75601b781a280fc3b33f1e0cd6aa5a92d9fb96c410e97/cryptography-44.0.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1923cb251c04be85eec9fda837661c67c1049063305d6be5721643c22dd4e2b7", size = 3922613 }, - { url = "https://files.pythonhosted.org/packages/28/34/6b3ac1d80fc174812486561cf25194338151780f27e438526f9c64e16869/cryptography-44.0.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:404fdc66ee5f83a1388be54300ae978b2efd538018de18556dde92575e05defc", size = 4137925 }, - { url = "https://files.pythonhosted.org/packages/d0/c7/c656eb08fd22255d21bc3129625ed9cd5ee305f33752ef2278711b3fa98b/cryptography-44.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c5eb858beed7835e5ad1faba59e865109f3e52b3783b9ac21e7e47dc5554e289", size = 3915417 }, - { url = "https://files.pythonhosted.org/packages/ef/82/72403624f197af0db6bac4e58153bc9ac0e6020e57234115db9596eee85d/cryptography-44.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f53c2c87e0fb4b0c00fa9571082a057e37690a8f12233306161c8f4b819960b7", size = 4155160 }, - { url = "https://files.pythonhosted.org/packages/a2/cd/2f3c440913d4329ade49b146d74f2e9766422e1732613f57097fea61f344/cryptography-44.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:9e6fc8a08e116fb7c7dd1f040074c9d7b51d74a8ea40d4df2fc7aa08b76b9e6c", size = 3932331 }, - { url = "https://files.pythonhosted.org/packages/7f/df/8be88797f0a1cca6e255189a57bb49237402b1880d6e8721690c5603ac23/cryptography-44.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d2436114e46b36d00f8b72ff57e598978b37399d2786fd39793c36c6d5cb1c64", size = 4017372 }, - { url = "https://files.pythonhosted.org/packages/af/36/5ccc376f025a834e72b8e52e18746b927f34e4520487098e283a719c205e/cryptography-44.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a01956ddfa0a6790d594f5b34fc1bfa6098aca434696a03cfdbe469b8ed79285", size = 4239657 }, - { url = "https://files.pythonhosted.org/packages/77/d4/fea74422326388bbac0c37b7489a0fcb1681a698c3b875959430ba550daa/cryptography-44.0.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:37d76e6863da3774cd9db5b409a9ecfd2c71c981c38788d3fcfaf177f447b731", size = 3338857 }, - { url = "https://files.pythonhosted.org/packages/1a/aa/ba8a7467c206cb7b62f09b4168da541b5109838627f582843bbbe0235e8e/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:f677e1268c4e23420c3acade68fac427fffcb8d19d7df95ed7ad17cdef8404f4", size = 3850615 }, - { url = "https://files.pythonhosted.org/packages/89/fa/b160e10a64cc395d090105be14f399b94e617c879efd401188ce0fea39ee/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f5e7cb1e5e56ca0933b4873c0220a78b773b24d40d186b6738080b73d3d0a756", size = 4081622 }, - { url = "https://files.pythonhosted.org/packages/47/8f/20ff0656bb0cf7af26ec1d01f780c5cfbaa7666736063378c5f48558b515/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:8b3e6eae66cf54701ee7d9c83c30ac0a1e3fa17be486033000f2a73a12ab507c", size = 3867546 }, - { url = "https://files.pythonhosted.org/packages/38/d9/28edf32ee2fcdca587146bcde90102a7319b2f2c690edfa627e46d586050/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:be4ce505894d15d5c5037167ffb7f0ae90b7be6f2a98f9a5c3442395501c32fa", size = 4090937 }, + { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" }, + { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" }, + { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" }, + { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" }, + { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" }, + { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" }, + { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" }, + { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" }, + { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" }, + { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" }, + { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" }, + { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" }, + { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" }, + { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" }, + { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" }, + { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" }, + { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" }, + { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" }, + { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" }, + { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" }, + { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" }, + { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" }, + { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" }, + { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" }, + { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" }, + { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" }, ] [[package]] name = "daphne" -version = "4.1.2" +version = "4.2.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "autobahn", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "twisted", extra = ["tls"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1a/c1/aedf180beb12395835cba791ce7239b8880009d9d37564d72b7590cde605/daphne-4.1.2.tar.gz", hash = "sha256:fcbcace38eb86624ae247c7ffdc8ac12f155d7d19eafac4247381896d6f33761", size = 37882 } +sdist = { url = "https://files.pythonhosted.org/packages/cd/9d/322b605fdc03b963cf2d33943321c8f4405e8d82e698bf49d1eed1ca40c4/daphne-4.2.1.tar.gz", hash = "sha256:5f898e700a1fda7addf1541d7c328606415e96a7bd768405f0463c312fcb31b3", size = 45600, upload-time = "2025-07-02T12:57:04.935Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ab/d6/466f9219281472ecc269ab1d351c5b22a3cfca2d52f72881917949e414df/daphne-4.1.2-py3-none-any.whl", hash = "sha256:618d1322bb4d875342b99dd2a10da2d9aae7ee3645f765965fdc1e658ea5290a", size = 30940 }, + { url = "https://files.pythonhosted.org/packages/01/34/6171ab34715ed210bcd6c2b38839cc792993cff4fe2493f50bc92b0086a0/daphne-4.2.1-py3-none-any.whl", hash = "sha256:881e96b387b95b35ad85acd855f229d7f5b79073d6649089c8a33f661885e055", size = 29015, upload-time = "2025-07-02T12:57:03.793Z" }, ] [[package]] name = "dateparser" -version = "1.2.0" +version = "1.2.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "python-dateutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -1295,43 +573,31 @@ dependencies = [ { name = "regex", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "tzlocal", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1a/b2/f6b29ab17d7959eb1a0a5c64f5011dc85051ad4e25e401cbddcc515db00f/dateparser-1.2.0.tar.gz", hash = "sha256:7975b43a4222283e0ae15be7b4999d08c9a70e2d378ac87385b1ccf2cffbbb30", size = 307260 } +sdist = { url = "https://files.pythonhosted.org/packages/a9/30/064144f0df1749e7bb5faaa7f52b007d7c2d08ec08fed8411aba87207f68/dateparser-1.2.2.tar.gz", hash = "sha256:986316f17cb8cdc23ea8ce563027c5ef12fc725b6fb1d137c14ca08777c5ecf7", size = 329840, upload-time = "2025-06-26T09:29:23.211Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/29/db12aa4dda81580be1999824a689bd52aa40061fc12c9ccdc3feab5ea718/dateparser-1.2.0-py2.py3-none-any.whl", hash = "sha256:0b21ad96534e562920a0083e97fd45fa959882d4162acc358705144520a35830", size = 294995 }, + { url = "https://files.pythonhosted.org/packages/87/22/f020c047ae1346613db9322638186468238bcfa8849b4668a22b97faad65/dateparser-1.2.2-py3-none-any.whl", hash = "sha256:5a5d7211a09013499867547023a2a0c91d5a27d15dd4dbcea676ea9fe66f2482", size = 315453, upload-time = "2025-06-26T09:29:21.412Z" }, ] [[package]] name = "decorator" -version = "5.1.1" +version = "5.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/66/0c/8d907af351aa16b42caae42f9d6aa37b900c67308052d10fdce809f8d952/decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330", size = 35016 } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073 }, -] - -[[package]] -name = "deprecated" -version = "1.2.15" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2e/a3/53e7d78a6850ffdd394d7048a31a6f14e44900adedf190f9a165f6b69439/deprecated-1.2.15.tar.gz", hash = "sha256:683e561a90de76239796e6b6feac66b99030d2dd3fcf61ef996330f14bbb9b0d", size = 2977612 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl", hash = "sha256:353bc4a8ac4bfc96800ddab349d89c25dec1079f65fd53acdcc1e0b975b21320", size = 9941 }, + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, ] [[package]] name = "django" -version = "5.1.4" +version = "6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sqlparse", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d3/e8/536555596dbb79f6e77418aeb40bdc1758c26725aba31919ba449e6d5e6a/Django-5.1.4.tar.gz", hash = "sha256:de450c09e91879fa5a307f696e57c851955c910a438a35e6b4c895e86bedc82a", size = 10716397 } +sdist = { url = "https://files.pythonhosted.org/packages/15/75/19762bfc4ea556c303d9af8e36f0cd910ab17dff6c8774644314427a2120/django-6.0.tar.gz", hash = "sha256:7b0c1f50c0759bbe6331c6a39c89ae022a84672674aeda908784617ef47d8e26", size = 10932418, upload-time = "2025-12-03T16:26:21.878Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/58/0b/8a4ab2c02982df4ed41e29f28f189459a7eba37899438e6bea7f39db793b/Django-5.1.4-py3-none-any.whl", hash = "sha256:236e023f021f5ce7dee5779de7b286565fdea5f4ab86bae5338e3f7b69896cf0", size = 8276471 }, + { url = "https://files.pythonhosted.org/packages/d7/ae/f19e24789a5ad852670d6885f5480f5e5895576945fcc01817dfd9bc002a/django-6.0-py3-none-any.whl", hash = "sha256:1cc2c7344303bbfb7ba5070487c17f7fc0b7174bbb0a38cebf03c675f5f19b6d", size = 8339181, upload-time = "2025-12-03T16:26:16.231Z" }, ] [[package]] @@ -1341,24 +607,23 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-settings-holder", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2e/3f/2377a4088c0bf7ce677bb0a526cbf898a11e5528941d7cda303efef3bd73/django_admin_data_views-0.4.3.tar.gz", hash = "sha256:bd287a5d874febd8b544f83b47d0846fbf7b3e00a7f6633912630053c7ae4298", size = 12519 } +sdist = { url = "https://files.pythonhosted.org/packages/2e/3f/2377a4088c0bf7ce677bb0a526cbf898a11e5528941d7cda303efef3bd73/django_admin_data_views-0.4.3.tar.gz", hash = "sha256:bd287a5d874febd8b544f83b47d0846fbf7b3e00a7f6633912630053c7ae4298", size = 12519, upload-time = "2024-11-24T14:18:00.406Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/4a/c441cc177beb536c80747eaffa13ea14214cb7a5b67f5ae7bbec6948ba72/django_admin_data_views-0.4.3-py3-none-any.whl", hash = "sha256:661b4d58161d283eee1d131013db3e83a499084724f48fd0cd5bd9315b768e38", size = 15398 }, + { url = "https://files.pythonhosted.org/packages/e7/4a/c441cc177beb536c80747eaffa13ea14214cb7a5b67f5ae7bbec6948ba72/django_admin_data_views-0.4.3-py3-none-any.whl", hash = "sha256:661b4d58161d283eee1d131013db3e83a499084724f48fd0cd5bd9315b768e38", size = 15398, upload-time = "2024-11-24T14:17:58.765Z" }, ] [[package]] name = "django-auth-ldap" -version = "5.1.0" +version = "5.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "python-ldap", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/91/e4/2e8781840cc54f719be3241e16640524a9aabf94a599f5e083b0115042ce/django_auth_ldap-5.1.0.tar.gz", hash = "sha256:9c607e8d9c53cf2a0ccafbe0acfc33eb1d1fd474c46ec52d30aee0dca1da9668", size = 55059 } +sdist = { url = "https://files.pythonhosted.org/packages/88/70/6f6a89474667376080f8362f7c17c744d1c52720f0eb085cf74182149efe/django_auth_ldap-5.2.0.tar.gz", hash = "sha256:08ba6efc0340d9874725a962311b14991e29a33593eb150a8fb640709dbfa80f", size = 55287, upload-time = "2025-05-07T12:15:56.774Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/47/f3492884addbb17672cc9a6053381162010d6e40ccd8440dedf22f72bc7f/django_auth_ldap-5.1.0-py3-none-any.whl", hash = "sha256:a5f7bdb54b2ab80e4e9eb080cd3e06e89e4c9d2d534ddb39b66cd970dd6d3536", size = 20833 }, + { url = "https://files.pythonhosted.org/packages/a1/65/0d26a8b5c19039305d7ae0e8e702613a9a1fe1ef3ebbd6206b9e104b7c43/django_auth_ldap-5.2.0-py3-none-any.whl", hash = "sha256:7dc6eb576ba36051850b580e4bdf4464e04bbe7367c3827a3121b4d7c51fb175", size = 20913, upload-time = "2025-05-07T12:15:54.962Z" }, ] [[package]] @@ -1368,66 +633,53 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "libcst", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.12' and sys_platform == 'darwin') or (python_full_version < '3.12' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7b/d4/65d2b1c54f35116bd2d31d1064c523ded729353633389ecfc283a93b4c47/django_autotyping-0.5.1.tar.gz", hash = "sha256:b48c57d3d358a608109dd47698e64466e596983e8729bff130669dd744588c25", size = 78974 } +sdist = { url = "https://files.pythonhosted.org/packages/7b/d4/65d2b1c54f35116bd2d31d1064c523ded729353633389ecfc283a93b4c47/django_autotyping-0.5.1.tar.gz", hash = "sha256:b48c57d3d358a608109dd47698e64466e596983e8729bff130669dd744588c25", size = 78974, upload-time = "2024-05-29T14:48:28.561Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/98/824638898b8272178610268e126cca4f35e0ac05536153f559c299149ac6/django_autotyping-0.5.1-py3-none-any.whl", hash = "sha256:3ee6ecd32a8d16e858ebce06d8d7ca5b477b32752a8143de48edc67b97d9084d", size = 96448 }, -] - -[[package]] -name = "django-charid-field" -version = "0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/65/95/4b56b02d2985ed958ad2704fd037eb92e52f695ad42dd6d99ec313509c40/django_charid_field-0.4.tar.gz", hash = "sha256:3d8a0f4395f4c9b19667800254924503016160051c166c61e935e7366036cd38", size = 7089 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/70/53/368241098a9666189ce15653255777c7a34c095d49224edb02df1298882f/django_charid_field-0.4-py3-none-any.whl", hash = "sha256:70f140cb15ddde8459fc5a6cd8c4d24ed08d4c2aac2212d24df0ac724bc411f4", size = 7584 }, + { url = "https://files.pythonhosted.org/packages/c7/98/824638898b8272178610268e126cca4f35e0ac05536153f559c299149ac6/django_autotyping-0.5.1-py3-none-any.whl", hash = "sha256:3ee6ecd32a8d16e858ebce06d8d7ca5b477b32752a8143de48edc67b97d9084d", size = 96448, upload-time = "2024-05-29T14:48:26.391Z" }, ] [[package]] name = "django-debug-toolbar" -version = "4.4.6" +version = "6.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sqlparse", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d4/9c/0a3238eda0a46df20f2e3fe2a30313d34f5042a1a737d08230b77c29a3e9/django_debug_toolbar-4.4.6.tar.gz", hash = "sha256:36e421cb908c2f0675e07f9f41e3d1d8618dc386392ec82d23bcfcd5d29c7044", size = 272610 } +sdist = { url = "https://files.pythonhosted.org/packages/c0/50/acae2dd379164f6f4c6b6b36fd48a4d21b02095a03f4df7c30a8d1f1a62c/django_debug_toolbar-6.1.0.tar.gz", hash = "sha256:e962ec350c9be8bdba918138e975a9cdb193f60ec396af2bb71b769e8e165519", size = 309141, upload-time = "2025-10-30T19:50:39.458Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/33/2036a472eedfbe49240dffea965242b3f444de4ea4fbeceb82ccea33a2ce/django_debug_toolbar-4.4.6-py3-none-any.whl", hash = "sha256:3beb671c9ec44ffb817fad2780667f172bd1c067dbcabad6268ce39a81335f45", size = 229621 }, + { url = "https://files.pythonhosted.org/packages/6d/72/685c978af45ad08257e2c69687a873eda6b6531c79b6e6091794c41c5ff6/django_debug_toolbar-6.1.0-py3-none-any.whl", hash = "sha256:e214dea4494087e7cebdcea84223819c5eb97f9de3110a3665ad673f0ba98413", size = 269069, upload-time = "2025-10-30T19:50:37.71Z" }, ] [[package]] name = "django-extensions" -version = "3.2.3" +version = "4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8a/f1/318684c9466968bf9a9c221663128206e460c1a67f595055be4b284cde8a/django-extensions-3.2.3.tar.gz", hash = "sha256:44d27919d04e23b3f40231c4ab7af4e61ce832ef46d610cc650d53e68328410a", size = 277216 } +sdist = { url = "https://files.pythonhosted.org/packages/6d/b3/ed0f54ed706ec0b54fd251cc0364a249c6cd6c6ec97f04dc34be5e929eac/django_extensions-4.1.tar.gz", hash = "sha256:7b70a4d28e9b840f44694e3f7feb54f55d495f8b3fa6c5c0e5e12bcb2aa3cdeb", size = 283078, upload-time = "2025-04-11T01:15:39.617Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/7e/ba12b9660642663f5273141018d2bec0a1cae1711f4f6d1093920e157946/django_extensions-3.2.3-py3-none-any.whl", hash = "sha256:9600b7562f79a92cbf1fde6403c04fee314608fefbb595502e34383ae8203401", size = 229868 }, + { url = "https://files.pythonhosted.org/packages/64/96/d967ca440d6a8e3861120f51985d8e5aec79b9a8bdda16041206adfe7adc/django_extensions-4.1-py3-none-any.whl", hash = "sha256:0699a7af28f2523bf8db309a80278519362cd4b6e1fd0a8cd4bf063e1e023336", size = 232980, upload-time = "2025-04-11T01:15:37.701Z" }, ] [[package]] name = "django-huey" -version = "1.2.1" +version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "huey", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/0c/a1da34c09fb5a0cc629026835fc5a46fb28a6ff208527d6b004bd685dfbb/django_huey-1.2.1.tar.gz", hash = "sha256:634abf1e707acef90dd00df4267458486f89a3117419000ec5584b1c4129701a", size = 10925 } +sdist = { url = "https://files.pythonhosted.org/packages/f2/a3/ca67a0c6b469f72a73e8e9e41dce6b918e35404c72994b78df5a5cea0a89/django_huey-1.3.0.tar.gz", hash = "sha256:011102430e949fe5807df2c44ccbfd812671a77e5dda552907c07ded554ab92f", size = 11059, upload-time = "2025-06-02T00:22:52.834Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/46/019699f3dcf2777f07b1d5465c7a4cf3d7e73b6f9e0ad8de53c73e3f9191/django_huey-1.2.1-py3-none-any.whl", hash = "sha256:59c82b72fd4b6e60c219bd1fbab78acfe68a1c8d3efb1d3e42798a67d01a4aa2", size = 12515 }, + { url = "https://files.pythonhosted.org/packages/ab/2b/7203e18a1b8c6086ca5ab5899105dc877484d974532da9346ca2c87bd964/django_huey-1.3.0-py3-none-any.whl", hash = "sha256:b2db87248638e8b242cfd3a80a708c8940a23c4b23738e1bc00d26b1760be996", size = 12611, upload-time = "2025-06-02T00:22:48.97Z" }, ] [[package]] name = "django-huey-monitor" -version = "0.9.0" +version = "0.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "bx-django-utils", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -1435,40 +687,43 @@ dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "huey", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6b/58/b51530283c18dcacda793fbb110ceeb051f7e16fc6c786d2ece1cd1d0aa9/django-huey-monitor-0.9.0.tar.gz", hash = "sha256:03366d98579c07e132672aa760373949fecec108a0e91229e870bb21453c800b", size = 253114 } +sdist = { url = "https://files.pythonhosted.org/packages/cb/65/b9f61b9047c5ccdf65b96dc1eff64129ea551b0c9b06869decf4a688d123/django_huey_monitor-0.10.1.tar.gz", hash = "sha256:8a2870400252cc0cb7c28f57436dd4559e946450940dd313e762e2e57e3a31a1", size = 139269, upload-time = "2025-06-02T10:12:43.721Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/2d/9203527bc703cb15d5934ece6d304869b5cc6c0737eb91920aece893bcd2/django_huey_monitor-0.9.0-py3-none-any.whl", hash = "sha256:1d5922d182e138e288f99d6cdb326cbed20c831d4c906c96cba148b0979e648a", size = 68457 }, + { url = "https://files.pythonhosted.org/packages/bd/fd/1a5e0cd136d94e9df9eb870e9f6a04d512e00d0347f0d2aa9d546e8ae7f5/django_huey_monitor-0.10.1-py3-none-any.whl", hash = "sha256:e73614393c5cc1254adc1d45848530fff0980f46b3d738b313b15a05963360a3", size = 68990, upload-time = "2025-06-02T10:12:42.196Z" }, ] [[package]] name = "django-ninja" -version = "1.3.0" +version = "1.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9c/77/89ee4ebaa5151b7d85cebaf8d6ec0b9e5074326c3ad8259c763763306d51/django_ninja-1.3.0.tar.gz", hash = "sha256:5b320e2dc0f41a6032bfa7e1ebc33559ae1e911a426f0c6be6674a50b20819be", size = 3702324 } +sdist = { url = "https://files.pythonhosted.org/packages/42/8e/10b4299aa37017bb026ae091b2192d05b3d4b78a9dc57d59c4f362551907/django_ninja-1.5.1.tar.gz", hash = "sha256:6acda68a64d60934c6fdccb4d97c3ac7f02cfefd78a5d87ae053effe081b17c7", size = 3719868, upload-time = "2025-12-04T11:35:46.615Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/00/72/fd2589323b40893d3224e174eeec0c4ce5a42c7d2d384d11ba269ad4d050/django_ninja-1.3.0-py3-none-any.whl", hash = "sha256:f58096b6c767d1403dfd6c49743f82d780d7b9688d9302ecab316ac1fa6131bb", size = 2423381 }, + { url = "https://files.pythonhosted.org/packages/0a/fc/124c3f999fbc77680777ff331ac9552227d7a6753639ef66dbba780fc6b4/django_ninja-1.5.1-py3-none-any.whl", hash = "sha256:135aaa1117dce8dfd7a1e80b4487a8cccee3a4182c3c8b562d08ea94e4d2cbdf", size = 2426577, upload-time = "2025-12-04T11:35:44.656Z" }, ] [[package]] name = "django-object-actions" -version = "4.3.0" +version = "5.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0c/15/71c427f94f74c391614280565e5f64fd30fc6ba0f5841b42f71afd6446db/django_object_actions-4.3.0.tar.gz", hash = "sha256:611f768d768c9ca7b48278573feb7c07966174f5c50a9323ab4d02d0c4b7501e", size = 18237 } +sdist = { url = "https://files.pythonhosted.org/packages/e4/3e/1a6e59a8f751e036b4d23edaa5252111dbcd89396850da7b00cfc0f75d72/django_object_actions-5.0.0.tar.gz", hash = "sha256:ea455f76344316b620f815e4103c0f5151530177d35202682fc1734027bf0116", size = 16364, upload-time = "2025-04-05T06:33:00.206Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/67/aa16ef6e77c2957711cc6f8ae4ce87dbc9318c8f8c4e92e2fabaddccb0d7/django_object_actions-4.3.0-py3-none-any.whl", hash = "sha256:1af87dedcfd5a35207a4b90c386c059e5f02ecf1d954e3131e25f4a04d01c963", size = 19279 }, + { url = "https://files.pythonhosted.org/packages/a7/27/639dd4f0d933438dd5102bf07242f85581fc5ef78c9e7628d2ed9cd4a34c/django_object_actions-5.0.0-py3-none-any.whl", hash = "sha256:1d5bce0fd38b73544130fae036d208f2811de5b0ca7ccb23486235e915015519", size = 14782, upload-time = "2025-04-05T06:32:58.261Z" }, ] [[package]] name = "django-settings-holder" -version = "0.2.2" +version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/76/a2/eca3105add8254158ebc67b605a81aceeefc69238e3eae87ed50c2e2c438/django_settings_holder-0.2.2.tar.gz", hash = "sha256:a894e1a0e2573ff72ed752b97f5c8b03cda2745b64d3baff81db4ebd1e505b03", size = 8606 } +dependencies = [ + { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/1d/810c15a408987262bf70fc1892d4d5c3b2c1ae62e8715b73592c8f46ed37/django_settings_holder-0.3.0.tar.gz", hash = "sha256:d41eb6d6023d61c08e395f2406fd6f047d1edff2f0346d04323f3681f12372ef", size = 8580, upload-time = "2025-04-27T13:15:42.069Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4f/55/250e5b80c785e2ca36f7db3346df0ba38ed63930cf791b2ad926a26dd466/django_settings_holder-0.2.2-py3-none-any.whl", hash = "sha256:37f229d44686dd2dc6f82ff75213c90f633c5fea0492df9c5660c775fa5d6941", size = 8689 }, + { url = "https://files.pythonhosted.org/packages/f5/e3/0759620f917f7f7585375c1edb2875ed6c95597cf6645c3f5a21e0d44046/django_settings_holder-0.3.0-py3-none-any.whl", hash = "sha256:97c69c47129fcd8be5fc351f80cf31c8f3f7ecaec418bc2c20200382a0be52c0", size = 8085, upload-time = "2025-04-27T13:15:40.817Z" }, ] [[package]] @@ -1481,41 +736,38 @@ dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-settings-holder", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "httpx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/41/15/865e72e1da78bc6c6865ff16b0dffb11db62999fc91bed8c3c1668eac4c1/django_signal_webhooks-0.3.1.tar.gz", hash = "sha256:23dc439be2fdea24b746726495eb1a7a59440809056482eebceb153d050a3f5b", size = 17806 } +sdist = { url = "https://files.pythonhosted.org/packages/41/15/865e72e1da78bc6c6865ff16b0dffb11db62999fc91bed8c3c1668eac4c1/django_signal_webhooks-0.3.1.tar.gz", hash = "sha256:23dc439be2fdea24b746726495eb1a7a59440809056482eebceb153d050a3f5b", size = 17806, upload-time = "2024-10-31T23:34:40.37Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/7a/0f193eb3351af74de8c3d0fa89f72005caf63ad9456e281e5cd9b2be1a10/django_signal_webhooks-0.3.1-py3-none-any.whl", hash = "sha256:863beb94f6536a09b04d516df6103037748891f5f4555df36796fb54c8649854", size = 22940 }, + { url = "https://files.pythonhosted.org/packages/eb/7a/0f193eb3351af74de8c3d0fa89f72005caf63ad9456e281e5cd9b2be1a10/django_signal_webhooks-0.3.1-py3-none-any.whl", hash = "sha256:863beb94f6536a09b04d516df6103037748891f5f4555df36796fb54c8649854", size = 22940, upload-time = "2024-10-31T23:34:38.614Z" }, ] [[package]] name = "django-stubs" -version = "5.1.1" +version = "5.2.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "django-stubs-ext", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, { name = "types-pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bf/60/1ae90eb6e2e107bc64a3de9de78a5add7f3b85e491113504eed38d6d2c63/django_stubs-5.1.1.tar.gz", hash = "sha256:126d354bbdff4906c4e93e6361197f6fbfb6231c3df6def85a291dae6f9f577b", size = 265624 } +sdist = { url = "https://files.pythonhosted.org/packages/6c/75/97626224fd8f1787bb6f7f06944efcfddd5da7764bf741cf7f59d102f4a0/django_stubs-5.2.8.tar.gz", hash = "sha256:9bba597c9a8ed8c025cae4696803d5c8be1cf55bfc7648a084cbf864187e2f8b", size = 257709, upload-time = "2025-12-01T08:13:09.569Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/c8/3081d5f994351248fcd60f9aab10cb2020bdd7df0f14e80854373e15d7d4/django_stubs-5.1.1-py3-none-any.whl", hash = "sha256:c4dc64260bd72e6d32b9e536e8dd0d9247922f0271f82d1d5132a18f24b388ac", size = 470790 }, + { url = "https://files.pythonhosted.org/packages/7d/3f/7c9543ad5ade5ce1d33d187a3abd82164570314ebee72c6206ab5c044ebf/django_stubs-5.2.8-py3-none-any.whl", hash = "sha256:a3c63119fd7062ac63d58869698d07c9e5ec0561295c4e700317c54e8d26716c", size = 508136, upload-time = "2025-12-01T08:13:07.963Z" }, ] [[package]] name = "django-stubs-ext" -version = "5.1.1" +version = "5.2.8" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/62/a7129909d3c94eac957c02eeb05ac57cbca81db4f3f6270a8503697f376a/django_stubs_ext-5.1.1.tar.gz", hash = "sha256:db7364e4f50ae7e5360993dbd58a3a57ea4b2e7e5bab0fbd525ccdb3e7975d1c", size = 9455 } +sdist = { url = "https://files.pythonhosted.org/packages/14/a2/d67f4a5200ff7626b104eddceaf529761cba4ed318a73ffdb0677551be73/django_stubs_ext-5.2.8.tar.gz", hash = "sha256:b39938c46d7a547cd84e4a6378dbe51a3dd64d70300459087229e5fee27e5c6b", size = 6487, upload-time = "2025-12-01T08:12:37.486Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/ed/f79ae5ad993bdf900d61892d2a9fc0145441a507a7579890fb8e21e4a7bc/django_stubs_ext-5.1.1-py3-none-any.whl", hash = "sha256:3907f99e178c93323e2ce908aef8352adb8c047605161f8d9e5e7b4efb5a6a9c", size = 8965 }, + { url = "https://files.pythonhosted.org/packages/da/2d/cb0151b780c3730cf0f2c0fcb1b065a5e88f877cf7a9217483c375353af1/django_stubs_ext-5.2.8-py3-none-any.whl", hash = "sha256:1dd5470c9675591362c78a157a3cf8aec45d0e7a7f0cf32f227a1363e54e0652", size = 9949, upload-time = "2025-12-01T08:12:36.397Z" }, ] [[package]] @@ -1525,80 +777,71 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/34/a6/f1beaf8f552fe90c153cc039316ebab942c23dfbc88588dde081fefca816/django_taggit-6.1.0.tar.gz", hash = "sha256:c4d1199e6df34125dd36db5eb0efe545b254dec3980ce5dd80e6bab3e78757c3", size = 38151 } +sdist = { url = "https://files.pythonhosted.org/packages/34/a6/f1beaf8f552fe90c153cc039316ebab942c23dfbc88588dde081fefca816/django_taggit-6.1.0.tar.gz", hash = "sha256:c4d1199e6df34125dd36db5eb0efe545b254dec3980ce5dd80e6bab3e78757c3", size = 38151, upload-time = "2024-09-29T08:07:39.477Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/34/4185c345530b91d05cb82e05d07148f481a5eb5dc2ac44e092b3daa6f206/django_taggit-6.1.0-py3-none-any.whl", hash = "sha256:ab776264bbc76cb3d7e49e1bf9054962457831bd21c3a42db9138b41956e4cf0", size = 75749 }, + { url = "https://files.pythonhosted.org/packages/6b/34/4185c345530b91d05cb82e05d07148f481a5eb5dc2ac44e092b3daa6f206/django_taggit-6.1.0-py3-none-any.whl", hash = "sha256:ab776264bbc76cb3d7e49e1bf9054962457831bd21c3a42db9138b41956e4cf0", size = 75749, upload-time = "2024-09-29T08:07:14.612Z" }, ] [[package]] name = "djdt-flamegraph" version = "0.2.13" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ce/75/bcd75d857c95195588cad1f09e7679b0c21958f513a06f89d267e81ec6d0/djdt_flamegraph-0.2.13.tar.gz", hash = "sha256:c07a71be58484636e021d4c49b129fd819f24c9128849cb59558e5141192dbf3", size = 15757 } +sdist = { url = "https://files.pythonhosted.org/packages/ce/75/bcd75d857c95195588cad1f09e7679b0c21958f513a06f89d267e81ec6d0/djdt_flamegraph-0.2.13.tar.gz", hash = "sha256:c07a71be58484636e021d4c49b129fd819f24c9128849cb59558e5141192dbf3", size = 15757, upload-time = "2020-01-17T05:40:39.472Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/36/85/c4e42d21cf748c696b8c05316bbd8e8666f17eeda0cf1743056f4cf7622b/djdt_flamegraph-0.2.13-py2.py3-none-any.whl", hash = "sha256:b3252b8cc9b586829166cc158b26952626cd6f41a3ffa92dceef2f5dbe5b99a0", size = 15256 }, + { url = "https://files.pythonhosted.org/packages/36/85/c4e42d21cf748c696b8c05316bbd8e8666f17eeda0cf1743056f4cf7622b/djdt_flamegraph-0.2.13-py2.py3-none-any.whl", hash = "sha256:b3252b8cc9b586829166cc158b26952626cd6f41a3ffa92dceef2f5dbe5b99a0", size = 15256, upload-time = "2020-01-17T05:40:37.799Z" }, ] [[package]] name = "docutils" version = "0.21.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444 } +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408 }, + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" }, ] [[package]] name = "et-xmlfile" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234 } +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059 }, -] - -[[package]] -name = "exceptiongroup" -version = "1.2.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, + { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" }, ] [[package]] name = "executing" -version = "2.1.0" +version = "2.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485 } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 }, + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, ] [[package]] name = "feedparser" -version = "6.0.11" +version = "6.0.12" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "sgmllib3k", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ff/aa/7af346ebeb42a76bf108027fe7f3328bb4e57a3a96e53e21fd9ef9dd6dd0/feedparser-6.0.11.tar.gz", hash = "sha256:c9d0407b64c6f2a065d0ebb292c2b35c01050cc0dc33757461aaabdc4c4184d5", size = 286197 } +sdist = { url = "https://files.pythonhosted.org/packages/dc/79/db7edb5e77d6dfbc54d7d9df72828be4318275b2e580549ff45a962f6461/feedparser-6.0.12.tar.gz", hash = "sha256:64f76ce90ae3e8ef5d1ede0f8d3b50ce26bcce71dd8ae5e82b1cd2d4a5f94228", size = 286579, upload-time = "2025-09-10T13:33:59.486Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/d4/8c31aad9cc18f451c49f7f9cfb5799dadffc88177f7917bc90a66459b1d7/feedparser-6.0.11-py3-none-any.whl", hash = "sha256:0be7ee7b395572b19ebeb1d6aafb0028dee11169f1c934e0ed67d54992f4ad45", size = 81343 }, + { url = "https://files.pythonhosted.org/packages/4e/eb/c96d64137e29ae17d83ad2552470bafe3a7a915e85434d9942077d7fd011/feedparser-6.0.12-py3-none-any.whl", hash = "sha256:6bbff10f5a52662c00a2e3f86a38928c37c48f77b3c511aedcd51de933549324", size = 81480, upload-time = "2025-09-10T13:33:58.022Z" }, ] [[package]] name = "flake8" -version = "7.1.1" +version = "7.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "mccabe", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pycodestyle", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pyflakes", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/37/72/e8d66150c4fcace3c0a450466aa3480506ba2cae7b61e100a2613afc3907/flake8-7.1.1.tar.gz", hash = "sha256:049d058491e228e03e67b390f311bbf88fce2dbaa8fa673e7aea87b7198b8d38", size = 48054 } +sdist = { url = "https://files.pythonhosted.org/packages/9b/af/fbfe3c4b5a657d79e5c47a2827a362f9e1b763336a52f926126aa6dc7123/flake8-7.3.0.tar.gz", hash = "sha256:fe044858146b9fc69b551a4b490d69cf960fcb78ad1edcb84e7fbb1b4a8e3872", size = 48326, upload-time = "2025-06-20T19:31:35.838Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/42/65004373ac4617464f35ed15931b30d764f53cdd30cc78d5aea349c8c050/flake8-7.1.1-py2.py3-none-any.whl", hash = "sha256:597477df7860daa5aa0fdd84bf5208a043ab96b8e96ab708770ae0364dd03213", size = 57731 }, + { url = "https://files.pythonhosted.org/packages/9f/56/13ab06b4f93ca7cac71078fbe37fcea175d3216f31f85c3168a6bbd0bb9a/flake8-7.3.0-py2.py3-none-any.whl", hash = "sha256:b9696257b9ce8beb888cdbe31cf885c90d31928fe202be0889a7cdafad32f01e", size = 57922, upload-time = "2025-06-20T19:31:34.425Z" }, ] [[package]] @@ -1608,43 +851,43 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "wcwidth", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", hash = "sha256:9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec", size = 308927 } +sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", hash = "sha256:9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec", size = 308927, upload-time = "2024-10-26T00:50:35.149Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", hash = "sha256:7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083", size = 44821 }, + { url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", hash = "sha256:7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083", size = 44821, upload-time = "2024-10-26T00:50:33.425Z" }, ] [[package]] name = "googleapis-common-protos" -version = "1.66.0" +version = "1.72.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ff/a7/8e9cccdb1c49870de6faea2a2764fa23f627dd290633103540209f03524c/googleapis_common_protos-1.66.0.tar.gz", hash = "sha256:c3e7b33d15fdca5374cc0a7346dd92ffa847425cc4ea941d970f13680052ec8c", size = 114376 } +sdist = { url = "https://files.pythonhosted.org/packages/e5/7b/adfd75544c415c487b33061fe7ae526165241c1ea133f9a9125a56b39fd8/googleapis_common_protos-1.72.0.tar.gz", hash = "sha256:e55a601c1b32b52d7a3e65f43563e2aa61bcd737998ee672ac9b951cd49319f5", size = 147433, upload-time = "2025-11-06T18:29:24.087Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/0f/c0713fb2b3d28af4b2fded3291df1c4d4f79a00d15c2374a9e010870016c/googleapis_common_protos-1.66.0-py2.py3-none-any.whl", hash = "sha256:d7abcd75fabb2e0ec9f74466401f6c119a0b498e27370e9be4c94cb7e382b8ed", size = 221682 }, + { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" }, ] [[package]] name = "h11" -version = "0.14.0" +version = "0.16.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] [[package]] name = "httpcore" -version = "1.0.7" +version = "1.0.9" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "certifi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "h11", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, ] [[package]] @@ -1657,16 +900,19 @@ dependencies = [ { name = "httpcore", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "idna", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] [[package]] name = "huey" -version = "2.5.2" +version = "2.5.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9c/fe/2e063984cdd512aa71e9c9c2a9200b58a830c532d25ca2c6cbc8e44bf7b7/huey-2.5.2.tar.gz", hash = "sha256:df33db474c05414ed40ee2110e9df692369871734da22d74ffb035a4bd74047f", size = 889357 } +sdist = { url = "https://files.pythonhosted.org/packages/e6/87/07796060836baf60727df5edae1579adcc8140f42fb7dea3c34ca7ce7fd3/huey-2.5.5.tar.gz", hash = "sha256:a39010628a9a1a9e91462f9bf33dc243b006a9f21193026ea47ae18949a12581", size = 895915, upload-time = "2025-12-05T02:26:54.226Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/c2/0543039071259cfdab525757022de8dad6d22c15a0e7352f1a50a1444a13/huey-2.5.5-py3-none-any.whl", hash = "sha256:82ac73343248c5d7acec04814f952c61f7793e11fd99d26ed9030137d32f912c", size = 76889, upload-time = "2025-12-05T02:26:52.668Z" }, +] [[package]] name = "hyperlink" @@ -1675,61 +921,60 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "idna", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3a/51/1947bd81d75af87e3bb9e34593a4cf118115a8feb451ce7a69044ef1412e/hyperlink-21.0.0.tar.gz", hash = "sha256:427af957daa58bc909471c6c40f74c5450fa123dd093fc53efd2e91d2705a56b", size = 140743 } +sdist = { url = "https://files.pythonhosted.org/packages/3a/51/1947bd81d75af87e3bb9e34593a4cf118115a8feb451ce7a69044ef1412e/hyperlink-21.0.0.tar.gz", hash = "sha256:427af957daa58bc909471c6c40f74c5450fa123dd093fc53efd2e91d2705a56b", size = 140743, upload-time = "2021-01-08T05:51:20.972Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6e/aa/8caf6a0a3e62863cbb9dab27135660acba46903b703e224f14f447e57934/hyperlink-21.0.0-py2.py3-none-any.whl", hash = "sha256:e6b14c37ecb73e89c77d78cdb4c2cc8f3fb59a885c5b3f819ff4ed80f25af1b4", size = 74638 }, + { url = "https://files.pythonhosted.org/packages/6e/aa/8caf6a0a3e62863cbb9dab27135660acba46903b703e224f14f447e57934/hyperlink-21.0.0-py2.py3-none-any.whl", hash = "sha256:e6b14c37ecb73e89c77d78cdb4c2cc8f3fb59a885c5b3f819ff4ed80f25af1b4", size = 74638, upload-time = "2021-01-08T05:51:22.906Z" }, ] [[package]] name = "idna" -version = "3.10" +version = "3.11" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, ] [[package]] name = "imagesize" version = "1.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026 } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769 }, + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, ] [[package]] name = "importlib-metadata" -version = "8.5.0" +version = "8.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", size = 55304 } +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514 }, + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, ] [[package]] name = "incremental" -version = "24.7.2" +version = "24.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, + { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/87/156b374ff6578062965afe30cc57627d35234369b3336cf244b240c8d8e6/incremental-24.7.2.tar.gz", hash = "sha256:fb4f1d47ee60efe87d4f6f0ebb5f70b9760db2b2574c59c8e8912be4ebd464c9", size = 28157 } +sdist = { url = "https://files.pythonhosted.org/packages/ef/3c/82e84109e02c492f382c711c58a3dd91badda6d746def81a1465f74dc9f5/incremental-24.11.0.tar.gz", hash = "sha256:87d3480dbb083c1d736222511a8cf380012a8176c2456d01ef483242abbbcf8c", size = 24000, upload-time = "2025-11-28T02:30:17.861Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/38/221e5b2ae676a3938c2c1919131410c342b6efc2baffeda395dd66eeca8f/incremental-24.7.2-py3-none-any.whl", hash = "sha256:8cb2c3431530bec48ad70513931a760f446ad6c25e8333ca5d95e24b0ed7b8fe", size = 20516 }, + { url = "https://files.pythonhosted.org/packages/1d/55/0f4df2a44053867ea9cbea73fc588b03c55605cd695cee0a3d86f0029cb2/incremental-24.11.0-py3-none-any.whl", hash = "sha256:a34450716b1c4341fe6676a0598e88a39e04189f4dce5dc96f656e040baa10b3", size = 21109, upload-time = "2025-11-28T02:30:16.442Z" }, ] [[package]] name = "iniconfig" -version = "2.0.0" +version = "2.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, ] [[package]] @@ -1739,20 +984,19 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "decorator", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "ipython", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/1b/7e07e7b752017f7693a0f4d41c13e5ca29ce8cbcfdcc1fd6c4ad8c0a27a0/ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726", size = 17042 } +sdist = { url = "https://files.pythonhosted.org/packages/3d/1b/7e07e7b752017f7693a0f4d41c13e5ca29ce8cbcfdcc1fd6c4ad8c0a27a0/ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726", size = 17042, upload-time = "2023-03-09T15:40:57.487Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/4c/b075da0092003d9a55cf2ecc1cae9384a1ca4f650d51b00fc59875fe76f6/ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4", size = 12130 }, + { url = "https://files.pythonhosted.org/packages/0c/4c/b075da0092003d9a55cf2ecc1cae9384a1ca4f650d51b00fc59875fe76f6/ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4", size = 12130, upload-time = "2023-03-09T15:40:55.021Z" }, ] [[package]] name = "ipython" -version = "8.30.0" +version = "9.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "decorator", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "exceptiongroup", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, + { name = "ipython-pygments-lexers", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "jedi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "matplotlib-inline", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pexpect", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -1760,11 +1004,22 @@ dependencies = [ { name = "pygments", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "stack-data", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "traitlets", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.12' and sys_platform == 'darwin') or (python_full_version < '3.12' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d8/8b/710af065ab8ed05649afa5bd1e07401637c9ec9fb7cfda9eac7e91e9fbd4/ipython-8.30.0.tar.gz", hash = "sha256:cb0a405a306d2995a5cbb9901894d240784a9f341394c6ba3f4fe8c6eb89ff6e", size = 5592205 } +sdist = { url = "https://files.pythonhosted.org/packages/12/51/a703c030f4928646d390b4971af4938a1b10c9dfce694f0d99a0bb073cb2/ipython-9.8.0.tar.gz", hash = "sha256:8e4ce129a627eb9dd221c41b1d2cdaed4ef7c9da8c17c63f6f578fe231141f83", size = 4424940, upload-time = "2025-12-03T10:18:24.353Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/f3/1332ba2f682b07b304ad34cad2f003adcfeb349486103f4b632335074a7c/ipython-8.30.0-py3-none-any.whl", hash = "sha256:85ec56a7e20f6c38fce7727dcca699ae4ffc85985aa7b23635a8008f918ae321", size = 820765 }, + { url = "https://files.pythonhosted.org/packages/f1/df/8ee1c5dd1e3308b5d5b2f2dfea323bb2f3827da8d654abb6642051199049/ipython-9.8.0-py3-none-any.whl", hash = "sha256:ebe6d1d58d7d988fbf23ff8ff6d8e1622cfdb194daf4b7b73b792c4ec3b85385", size = 621374, upload-time = "2025-12-03T10:18:22.335Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, ] [[package]] @@ -1774,69 +1029,77 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "parso", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, ] [[package]] name = "jinja2" -version = "3.1.4" +version = "3.1.6" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markupsafe", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ed/55/39036716d19cab0747a5020fc7e907f362fbf48c984b14e62127f7e68e5d/jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369", size = 240245 } +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", size = 133271 }, + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] [[package]] name = "lexid" version = "2021.1006" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/60/0b/28a3f9abc75abbf1fa996eb2dd77e1e33a5d1aac62566e3f60a8ec8b8a22/lexid-2021.1006.tar.gz", hash = "sha256:509a3a4cc926d3dbf22b203b18a4c66c25e6473fb7c0e0d30374533ac28bafe5", size = 11525 } +sdist = { url = "https://files.pythonhosted.org/packages/60/0b/28a3f9abc75abbf1fa996eb2dd77e1e33a5d1aac62566e3f60a8ec8b8a22/lexid-2021.1006.tar.gz", hash = "sha256:509a3a4cc926d3dbf22b203b18a4c66c25e6473fb7c0e0d30374533ac28bafe5", size = 11525, upload-time = "2021-04-02T20:18:34.668Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/e3/35764404a4b7e2021be1f88f42264c2e92e0c4720273559a62461ce64a47/lexid-2021.1006-py2.py3-none-any.whl", hash = "sha256:5526bb5606fd74c7add23320da5f02805bddd7c77916f2dc1943e6bada8605ed", size = 7587 }, + { url = "https://files.pythonhosted.org/packages/cf/e3/35764404a4b7e2021be1f88f42264c2e92e0c4720273559a62461ce64a47/lexid-2021.1006-py2.py3-none-any.whl", hash = "sha256:5526bb5606fd74c7add23320da5f02805bddd7c77916f2dc1943e6bada8605ed", size = 7587, upload-time = "2021-04-02T20:18:33.129Z" }, ] [[package]] name = "libcst" -version = "1.5.1" +version = "1.8.6" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/a6/a19b587108b15d3e0bfa8d0944265809581c8b8e161e22c9c9060afbbf4a/libcst-1.5.1.tar.gz", hash = "sha256:71cb294db84df9e410208009c732628e920111683c2f2b2e0c5b71b98464f365", size = 773387 } +sdist = { url = "https://files.pythonhosted.org/packages/de/cd/337df968b38d94c5aabd3e1b10630f047a2b345f6e1d4456bd9fe7417537/libcst-1.8.6.tar.gz", hash = "sha256:f729c37c9317126da9475bdd06a7208eb52fcbd180a6341648b45a56b4ba708b", size = 891354, upload-time = "2025-11-03T22:33:30.621Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/46/468a892cdc218272925c3fc4b3ae81cd81f24eabe29a35ba5d017ee35ee1/libcst-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ab83633e61ee91df575a3838b1e73c371f19d4916bf1816554933235553d41ea", size = 2124113 }, - { url = "https://files.pythonhosted.org/packages/8c/b7/b8e7b24629b32e4ba4822e3291c19dc63f2f95fea40230e630ec8df0d3f1/libcst-1.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b58a49895d95ec1fd34fad041a142d98edf9b51fcaf632337c13befeb4d51c7c", size = 2032570 }, - { url = "https://files.pythonhosted.org/packages/d3/db/1e064189f75bc68091fa4fe5b0b062493384544e47d8d50520d00d7bfe1c/libcst-1.5.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d9ec764aa781ef35ab96b693569ac3dced16df9feb40ee6c274d13e86a1472e", size = 2173960 }, - { url = "https://files.pythonhosted.org/packages/02/86/b03471cae3e8372e8e5350f90645136106bc9780d87bb46939dc68c938b5/libcst-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99bbffd8596d192bc0e844a4cf3c4fc696979d4e20ab1c0774a01768a59b47ed", size = 2264452 }, - { url = "https://files.pythonhosted.org/packages/3b/66/729dcfbf82d64646f11b3875270177ad35057fe1908bc29366a6d530dddb/libcst-1.5.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec6ee607cfe4cc4cc93e56e0188fdb9e50399d61a1262d58229752946f288f5e", size = 2341370 }, - { url = "https://files.pythonhosted.org/packages/db/23/177ca265dcaf2af4665ca359dd9967f9000dc74fc78fd3b6a231301ab972/libcst-1.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:72132756f985a19ef64d702a821099d4afc3544974662772b44cbc55b7279727", size = 2219726 }, - { url = "https://files.pythonhosted.org/packages/48/b9/2b292403ea5343143dfb93ad04da17752db3c77e7796e1f5eee00247b2c3/libcst-1.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:40b75bf2d70fc0bc26b1fa73e61bdc46fef59f5c71aedf16128e7c33db8d5e40", size = 2325121 }, - { url = "https://files.pythonhosted.org/packages/14/c1/83f7ff3a225ad09527b8d15b410e1bba168bafe0d134d93645b1d8b69859/libcst-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:db7711a762b0327b581be5a963908fecd74412bdda34db34553faa521563c22d", size = 2123894 }, - { url = "https://files.pythonhosted.org/packages/5b/70/7b765a0a8db8084703fe408ed1c583c434e99b8ec3e7c6192732a1959eb8/libcst-1.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa524bd012aaae1f485fd44490ef5abf708b14d2addc0f06b28de3e4585c4b9e", size = 2032548 }, - { url = "https://files.pythonhosted.org/packages/3c/01/d4111674d3cfe817c12ef79f8d39b2058a3bd8cd01a307a7db62118cd0ed/libcst-1.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3ffb8135c09e41e8cf710b152c33e9b7f1d0d0b9f242bae0c502eb082fdb1fb", size = 2173948 }, - { url = "https://files.pythonhosted.org/packages/4e/3b/0e7698e7715d2ed44512718dd6f45d5d698498b5c9fa906b4028a369a7f6/libcst-1.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76a8ac7a84f9b6f678a668bff85b360e0a93fa8d7f25a74a206a28110734bb2a", size = 2264422 }, - { url = "https://files.pythonhosted.org/packages/0d/c4/a76444a28015fb7327cfdbde7d3f88f633e88fce2fe910c7aaa7d4780422/libcst-1.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89c808bdb5fa9ca02df41dd234cbb0e9de0d2e0c029c7063d5435a9f6781cc10", size = 2341569 }, - { url = "https://files.pythonhosted.org/packages/54/1c/3f116e3baa47f71929467b404643c09e31af7acb77de8d2b3fe5d1b06212/libcst-1.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40fbbaa8b839bfbfa5b300623ca2b6b0768b58bbc31b341afbc99110c9bee232", size = 2219836 }, - { url = "https://files.pythonhosted.org/packages/ea/f7/746b6d91125cf1f398889d1b4488b10cc3df6b35d9762c2131294a1e8217/libcst-1.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c7021e3904d8d088c369afc3fe17c279883e583415ef07edacadba76cfbecd27", size = 2325108 }, - { url = "https://files.pythonhosted.org/packages/8f/0c/eac92358d05e75516f15654fb1550c9af165ce5a19f2b8adf44916ebebc4/libcst-1.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:666813950b8637af0c0e96b1ca46f5d5f183d2fe50bbac2186f5b283a99f3529", size = 2122234 }, - { url = "https://files.pythonhosted.org/packages/b3/26/6925af831f039e27eb380ba64448f33aea255ab6ecae6b5deec6ec637197/libcst-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b58b36022ae77a5a00002854043ae95c03e92f6062ad08473eff326f32efa0", size = 2031324 }, - { url = "https://files.pythonhosted.org/packages/e0/87/1b593bdddcb0d38d2232dab96b1f92deb2481c72063394f0394f680ff5b3/libcst-1.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb13d7c598fe9a798a1d22eae56ab3d3d599b38b83436039bd6ae229fc854d7", size = 2172432 }, - { url = "https://files.pythonhosted.org/packages/88/27/966f9fe2652aa496a85503333559937e58979eef674f9803c995d6704c44/libcst-1.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5987daff8389b0df60b5c20499ff4fb73fc03cb3ae1f6a746eefd204ed08df85", size = 2263445 }, - { url = "https://files.pythonhosted.org/packages/ff/79/f172226edbdd5b3a31d3c270e4407b35e3f5b0c6e404967e42314f1b434e/libcst-1.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00f3d2f32ee081bad3394546b0b9ac5e31686d3b5cfe4892d716d2ba65f9ec08", size = 2343044 }, - { url = "https://files.pythonhosted.org/packages/91/f2/664ae80583c66bcc3a2debcc8bab04e6843c3a6ac02e94050dddb5e5909c/libcst-1.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1ff21005c33b634957a98db438e882522febf1cacc62fa716f29e163a3f5871a", size = 2217129 }, - { url = "https://files.pythonhosted.org/packages/8b/df/b6b506d50f0a00a49d4e6217fd521c208cbf8693687cd0ac5880507ca6d1/libcst-1.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:15697ea9f1edbb9a263364d966c72abda07195d1c1a6838eb79af057f1040770", size = 2322129 }, - { url = "https://files.pythonhosted.org/packages/ff/68/89e1f0aa5697d9d7c9a78f630ffb65c43d5820008e5141504206836b86ce/libcst-1.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:06a9b4c9b76da4a7399e6f1f3a325196fb5febd3ea59fac1f68e2116f3517cd8", size = 2122230 }, - { url = "https://files.pythonhosted.org/packages/0f/1a/c23ab5bccd26f08c7faf982a3a2ab7a78d39502c4304585d107a160d9aa4/libcst-1.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:940ec4c8db4c2d620a7268d6c83e64ff646e4afd74ae5183d0f0ef3b80e05be0", size = 2031325 }, - { url = "https://files.pythonhosted.org/packages/d6/5b/a0f1bbd74054ef592c32ec0956ba083585af9b835c19a8d4b78ba536ec55/libcst-1.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fbccb016b1ac6d892344300dcccc8a16887b71bb7f875ba56c0ed6c1a7ade8be", size = 2172432 }, - { url = "https://files.pythonhosted.org/packages/42/d4/ad8af53181fbcd44913925498bdd05d2a76f170253883c0183cf237c5173/libcst-1.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c615af2117320e9a218083c83ec61227d3547e38a0de80329376971765f27a9e", size = 2263442 }, - { url = "https://files.pythonhosted.org/packages/c5/ed/a152f3b0b34c833a09c424336fd464b5b053b1e07e012a95887a7292c55a/libcst-1.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02b38fa4d9f13e79fe69e9b5407b9e173557bcfb5960f7866cf4145af9c7ae09", size = 2343045 }, - { url = "https://files.pythonhosted.org/packages/d1/43/d84090dc9b560ee1586e8ec8e3af34488695c52df244a0d9c3a473401e01/libcst-1.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3334afe9e7270e175de01198f816b0dc78dda94d9d72152b61851c323e4e741e", size = 2217130 }, - { url = "https://files.pythonhosted.org/packages/7a/95/c82b3f9fde6d5476837111e05d563542b5922ebe929c849e67c2a4ef2638/libcst-1.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:26c804fa8091747128579013df0b5f8e6b0c7904d9c4ee83841f136f53e18684", size = 2322130 }, + { url = "https://files.pythonhosted.org/packages/3a/60/4105441989e321f7ad0fd28ffccb83eb6aac0b7cfb0366dab855dcccfbe5/libcst-1.8.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b188e626ce61de5ad1f95161b8557beb39253de4ec74fc9b1f25593324a0279c", size = 2204202, upload-time = "2025-11-03T22:32:52.311Z" }, + { url = "https://files.pythonhosted.org/packages/67/2f/51a6f285c3a183e50cfe5269d4a533c21625aac2c8de5cdf2d41f079320d/libcst-1.8.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:87e74f7d7dfcba9efa91127081e22331d7c42515f0a0ac6e81d4cf2c3ed14661", size = 2083581, upload-time = "2025-11-03T22:32:54.269Z" }, + { url = "https://files.pythonhosted.org/packages/2f/64/921b1c19b638860af76cdb28bc81d430056592910b9478eea49e31a7f47a/libcst-1.8.6-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:3a926a4b42015ee24ddfc8ae940c97bd99483d286b315b3ce82f3bafd9f53474", size = 2236495, upload-time = "2025-11-03T22:32:55.723Z" }, + { url = "https://files.pythonhosted.org/packages/12/a8/b00592f9bede618cbb3df6ffe802fc65f1d1c03d48a10d353b108057d09c/libcst-1.8.6-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:3f4fbb7f569e69fd9e89d9d9caa57ca42c577c28ed05062f96a8c207594e75b8", size = 2301466, upload-time = "2025-11-03T22:32:57.337Z" }, + { url = "https://files.pythonhosted.org/packages/af/df/790d9002f31580fefd0aec2f373a0f5da99070e04c5e8b1c995d0104f303/libcst-1.8.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:08bd63a8ce674be431260649e70fca1d43f1554f1591eac657f403ff8ef82c7a", size = 2300264, upload-time = "2025-11-03T22:32:58.852Z" }, + { url = "https://files.pythonhosted.org/packages/21/de/dc3f10e65bab461be5de57850d2910a02c24c3ddb0da28f0e6e4133c3487/libcst-1.8.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e00e275d4ba95d4963431ea3e409aa407566a74ee2bf309a402f84fc744abe47", size = 2408572, upload-time = "2025-11-03T22:33:00.552Z" }, + { url = "https://files.pythonhosted.org/packages/95/a1/30bc61e8719f721a5562f77695e6154e9092d1bdf467aa35d0806dcd6cea/libcst-1.8.6-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:55ec021a296960c92e5a33b8d93e8ad4182b0eab657021f45262510a58223de1", size = 2188980, upload-time = "2025-11-03T22:33:05.152Z" }, + { url = "https://files.pythonhosted.org/packages/2c/14/c660204532407c5628e3b615015a902ed2d0b884b77714a6bdbe73350910/libcst-1.8.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ba9ab2b012fbd53b36cafd8f4440a6b60e7e487cd8b87428e57336b7f38409a4", size = 2074828, upload-time = "2025-11-03T22:33:06.864Z" }, + { url = "https://files.pythonhosted.org/packages/82/e2/c497c354943dff644749f177ee9737b09ed811b8fc842b05709a40fe0d1b/libcst-1.8.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c0a0cc80aebd8aa15609dd4d330611cbc05e9b4216bcaeabba7189f99ef07c28", size = 2225568, upload-time = "2025-11-03T22:33:08.354Z" }, + { url = "https://files.pythonhosted.org/packages/86/ef/45999676d07bd6d0eefa28109b4f97124db114e92f9e108de42ba46a8028/libcst-1.8.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:42a4f68121e2e9c29f49c97f6154e8527cd31021809cc4a941c7270aa64f41aa", size = 2286523, upload-time = "2025-11-03T22:33:10.206Z" }, + { url = "https://files.pythonhosted.org/packages/f4/6c/517d8bf57d9f811862f4125358caaf8cd3320a01291b3af08f7b50719db4/libcst-1.8.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a434c521fadaf9680788b50d5c21f4048fa85ed19d7d70bd40549fbaeeecab1", size = 2288044, upload-time = "2025-11-03T22:33:11.628Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/24d7d49478ffb61207f229239879845da40a374965874f5ee60f96b02ddb/libcst-1.8.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a65f844d813ab4ef351443badffa0ae358f98821561d19e18b3190f59e71996", size = 2392605, upload-time = "2025-11-03T22:33:12.962Z" }, +] + +[[package]] +name = "librt" +version = "0.7.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/93/e4/b59bdf1197fdf9888452ea4d2048cdad61aef85eb83e99dc52551d7fdc04/librt-0.7.4.tar.gz", hash = "sha256:3871af56c59864d5fd21d1ac001eb2fb3b140d52ba0454720f2e4a19812404ba", size = 145862, upload-time = "2025-12-15T16:52:43.862Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/74/81/6921e65c8708eb6636bbf383aa77e6c7dad33a598ed3b50c313306a2da9d/librt-0.7.4-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4f1ee004942eaaed6e06c087d93ebc1c67e9a293e5f6b9b5da558df6bf23dc5d", size = 55191, upload-time = "2025-12-15T16:52:01.97Z" }, + { url = "https://files.pythonhosted.org/packages/0d/d6/3eb864af8a8de8b39cc8dd2e9ded1823979a27795d72c4eea0afa8c26c9f/librt-0.7.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d854c6dc0f689bad7ed452d2a3ecff58029d80612d336a45b62c35e917f42d23", size = 56898, upload-time = "2025-12-15T16:52:03.356Z" }, + { url = "https://files.pythonhosted.org/packages/49/bc/b1d4c0711fdf79646225d576faee8747b8528a6ec1ceb6accfd89ade7102/librt-0.7.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a4f7339d9e445280f23d63dea842c0c77379c4a47471c538fc8feedab9d8d063", size = 163725, upload-time = "2025-12-15T16:52:04.572Z" }, + { url = "https://files.pythonhosted.org/packages/2c/08/61c41cd8f0a6a41fc99ea78a2205b88187e45ba9800792410ed62f033584/librt-0.7.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39003fc73f925e684f8521b2dbf34f61a5deb8a20a15dcf53e0d823190ce8848", size = 172469, upload-time = "2025-12-15T16:52:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c7/4ee18b4d57f01444230bc18cf59103aeab8f8c0f45e84e0e540094df1df1/librt-0.7.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bb15ee29d95875ad697d449fe6071b67f730f15a6961913a2b0205015ca0843", size = 186804, upload-time = "2025-12-15T16:52:07.192Z" }, + { url = "https://files.pythonhosted.org/packages/a1/af/009e8ba3fbf830c936842da048eda1b34b99329f402e49d88fafff6525d1/librt-0.7.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:02a69369862099e37d00765583052a99d6a68af7e19b887e1b78fee0146b755a", size = 181807, upload-time = "2025-12-15T16:52:08.554Z" }, + { url = "https://files.pythonhosted.org/packages/85/26/51ae25f813656a8b117c27a974f25e8c1e90abcd5a791ac685bf5b489a1b/librt-0.7.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ec72342cc4d62f38b25a94e28b9efefce41839aecdecf5e9627473ed04b7be16", size = 175595, upload-time = "2025-12-15T16:52:10.186Z" }, + { url = "https://files.pythonhosted.org/packages/48/93/36d6c71f830305f88996b15c8e017aa8d1e03e2e947b40b55bbf1a34cf24/librt-0.7.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:776dbb9bfa0fc5ce64234b446995d8d9f04badf64f544ca036bd6cff6f0732ce", size = 196504, upload-time = "2025-12-15T16:52:11.472Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a0/24941f85960774a80d4b3c2aec651d7d980466da8101cae89e8b032a3e21/librt-0.7.4-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b4c25312c7f4e6ab35ab16211bdf819e6e4eddcba3b2ea632fb51c9a2a97e105", size = 57369, upload-time = "2025-12-15T16:52:16.782Z" }, + { url = "https://files.pythonhosted.org/packages/77/a0/ddb259cae86ab415786c1547d0fe1b40f04a7b089f564fd5c0242a3fafb2/librt-0.7.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:618b7459bb392bdf373f2327e477597fff8f9e6a1878fffc1b711c013d1b0da4", size = 59230, upload-time = "2025-12-15T16:52:18.259Z" }, + { url = "https://files.pythonhosted.org/packages/31/11/77823cb530ab8a0c6fac848ac65b745be446f6f301753b8990e8809080c9/librt-0.7.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1437c3f72a30c7047f16fd3e972ea58b90172c3c6ca309645c1c68984f05526a", size = 183869, upload-time = "2025-12-15T16:52:19.457Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ce/157db3614cf3034b3f702ae5ba4fefda4686f11eea4b7b96542324a7a0e7/librt-0.7.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c96cb76f055b33308f6858b9b594618f1b46e147a4d03a4d7f0c449e304b9b95", size = 194606, upload-time = "2025-12-15T16:52:20.795Z" }, + { url = "https://files.pythonhosted.org/packages/30/ef/6ec4c7e3d6490f69a4fd2803516fa5334a848a4173eac26d8ee6507bff6e/librt-0.7.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28f990e6821204f516d09dc39966ef8b84556ffd648d5926c9a3f681e8de8906", size = 206776, upload-time = "2025-12-15T16:52:22.229Z" }, + { url = "https://files.pythonhosted.org/packages/ad/22/750b37bf549f60a4782ab80e9d1e9c44981374ab79a7ea68670159905918/librt-0.7.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc4aebecc79781a1b77d7d4e7d9fe080385a439e198d993b557b60f9117addaf", size = 203205, upload-time = "2025-12-15T16:52:23.603Z" }, + { url = "https://files.pythonhosted.org/packages/7a/87/2e8a0f584412a93df5faad46c5fa0a6825fdb5eba2ce482074b114877f44/librt-0.7.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:022cc673e69283a42621dd453e2407cf1647e77f8bd857d7ad7499901e62376f", size = 196696, upload-time = "2025-12-15T16:52:24.951Z" }, + { url = "https://files.pythonhosted.org/packages/e5/ca/7bf78fa950e43b564b7de52ceeb477fb211a11f5733227efa1591d05a307/librt-0.7.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2b3ca211ae8ea540569e9c513da052699b7b06928dcda61247cb4f318122bdb5", size = 217191, upload-time = "2025-12-15T16:52:26.194Z" }, ] [[package]] @@ -1846,14 +1109,14 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "uc-micro-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946 } +sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820 }, + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, ] [[package]] name = "logfire" -version = "2.8.0" +version = "4.16.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "executing", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -1862,26 +1125,26 @@ dependencies = [ { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/23/25/d5f4bf06441540f0c8dc350271d8a76fb733a7d4cf9c79d4188469d55b82/logfire-2.8.0.tar.gz", hash = "sha256:443da9547d88db384fb1f00d626ebecd18964a6402cf6f6af8497efa000bd0ee", size = 257461 } +sdist = { url = "https://files.pythonhosted.org/packages/e2/60/b8040db3598a55da64c45e3e689f2baa87389a4648a6f46ba80be3329f23/logfire-4.16.0.tar.gz", hash = "sha256:03a3ab8fdc13399309cb55d69cba7a6fcbad3526cfad85fc4f72e7d75e22b654", size = 550759, upload-time = "2025-12-04T16:16:39.477Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/6b/f000ac13a5758c846eb50a1d4eea6fcea9f47529721739f8deea42d45896/logfire-2.8.0-py3-none-any.whl", hash = "sha256:1cffd2971e1bed4ccc7b3a3a4693a0c8764127d2644b2f14de291fa6dfbf55af", size = 174908 }, + { url = "https://files.pythonhosted.org/packages/53/f7/ffcf81eb4aea75e40c0646b9519947d2070626c5d533922df92975045181/logfire-4.16.0-py3-none-any.whl", hash = "sha256:8f895f6c2efa593ad6d49e1b06d8e6e351d3dd0cad61ce5def0c3d401f8ea707", size = 229122, upload-time = "2025-12-04T16:16:35.963Z" }, ] [package.optional-dependencies] django = [ + { name = "opentelemetry-instrumentation-asgi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-instrumentation-django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] [[package]] name = "mailchecker" -version = "6.0.14" +version = "6.0.19" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f7/bc/a43b46fcae5f67b0e4c7be4d1c5a1e59763ade932bcc45d5db8501c9d18d/mailchecker-6.0.14.tar.gz", hash = "sha256:fc5670197430c78eabd64a0fdb42d2457c5ca9540210c5a1913d9795786d2a7d", size = 322372 } +sdist = { url = "https://files.pythonhosted.org/packages/6a/fc/92e55ba87d0c44a810e522e3c19ca8d0e87263a4d43d30b35608d38d72ab/mailchecker-6.0.19.tar.gz", hash = "sha256:32e2d074688565b85dff565cf959d3a37516dc4032212cf3fdcd45dc3d05d941", size = 322642, upload-time = "2025-10-19T12:13:07.717Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/a2/3c438833ac75e3d4d1d6c6a586a19e0f5c1aa39cfc40d0c0eddc7d43d0ec/mailchecker-6.0.14-py3-none-any.whl", hash = "sha256:b530b640312f760364ce1653a768ada870b838dff0beb38d59f025f9e6b74134", size = 322586 }, + { url = "https://files.pythonhosted.org/packages/59/89/4356650346b22c1054a0192c2455dddd75675d69badaf4f7720f72d2179c/mailchecker-6.0.19-py3-none-any.whl", hash = "sha256:d6c7aec63fa53e217cee82d86b9fbac3adef0f6d115a5f78bf70dfebbc56ef85", size = 322860, upload-time = "2025-10-19T12:13:05.979Z" }, ] [[package]] @@ -1891,143 +1154,129 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "mdurl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, ] [[package]] name = "markupsafe" -version = "3.0.2" +version = "3.0.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 }, - { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 }, - { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 }, - { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 }, - { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 }, - { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 }, - { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 }, - { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 }, - { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 }, - { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 }, - { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 }, - { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 }, - { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 }, - { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 }, - { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 }, - { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 }, - { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, - { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, - { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, - { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, - { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, - { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, - { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, - { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, - { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, - { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, - { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, - { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, - { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, - { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, - { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, - { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, - { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, - { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, - { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, - { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, - { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, - { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, - { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, - { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, ] [[package]] name = "matplotlib-inline" -version = "0.1.7" +version = "0.2.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "traitlets", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, ] [[package]] name = "mccabe" version = "0.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658 } +sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658, upload-time = "2022-01-24T01:14:51.113Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350 }, + { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350, upload-time = "2022-01-24T01:14:49.62Z" }, ] [[package]] name = "mdit-py-plugins" -version = "0.4.2" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markdown-it-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542 } +sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316 }, + { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" }, ] [[package]] name = "mdurl" version = "0.1.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, ] [[package]] name = "mypy" -version = "1.13.0" +version = "1.19.1" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "librt", marker = "(platform_python_implementation != 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, { name = "mypy-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, + { name = "pathspec", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e8/21/7e9e523537991d145ab8a0a2fd98548d67646dc2aaaf6091c31ad883e7c1/mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e", size = 3152532 } +sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5e/8c/206de95a27722b5b5a8c85ba3100467bd86299d92a4f71c6b9aa448bfa2f/mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a", size = 11020731 }, - { url = "https://files.pythonhosted.org/packages/ab/bb/b31695a29eea76b1569fd28b4ab141a1adc9842edde080d1e8e1776862c7/mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80", size = 10184276 }, - { url = "https://files.pythonhosted.org/packages/a5/2d/4a23849729bb27934a0e079c9c1aad912167d875c7b070382a408d459651/mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7", size = 12587706 }, - { url = "https://files.pythonhosted.org/packages/5c/c3/d318e38ada50255e22e23353a469c791379825240e71b0ad03e76ca07ae6/mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f", size = 13105586 }, - { url = "https://files.pythonhosted.org/packages/d0/19/de0822609e5b93d02579075248c7aa6ceaddcea92f00bf4ea8e4c22e3598/mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d", size = 10939027 }, - { url = "https://files.pythonhosted.org/packages/c8/71/6950fcc6ca84179137e4cbf7cf41e6b68b4a339a1f5d3e954f8c34e02d66/mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d", size = 10108699 }, - { url = "https://files.pythonhosted.org/packages/26/50/29d3e7dd166e74dc13d46050b23f7d6d7533acf48f5217663a3719db024e/mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b", size = 12506263 }, - { url = "https://files.pythonhosted.org/packages/3f/1d/676e76f07f7d5ddcd4227af3938a9c9640f293b7d8a44dd4ff41d4db25c1/mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73", size = 12984688 }, - { url = "https://files.pythonhosted.org/packages/fb/31/c526a7bd2e5c710ae47717c7a5f53f616db6d9097caf48ad650581e81748/mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5", size = 11077900 }, - { url = "https://files.pythonhosted.org/packages/83/67/b7419c6b503679d10bd26fc67529bc6a1f7a5f220bbb9f292dc10d33352f/mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e", size = 10074818 }, - { url = "https://files.pythonhosted.org/packages/ba/07/37d67048786ae84e6612575e173d713c9a05d0ae495dde1e68d972207d98/mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2", size = 12589275 }, - { url = "https://files.pythonhosted.org/packages/1f/17/b1018c6bb3e9f1ce3956722b3bf91bff86c1cefccca71cec05eae49d6d41/mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0", size = 13037783 }, - { url = "https://files.pythonhosted.org/packages/11/bb/ab4cfdc562cad80418f077d8be9b4491ee4fb257440da951b85cbb0a639e/mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7", size = 11069721 }, - { url = "https://files.pythonhosted.org/packages/59/3b/a393b1607cb749ea2c621def5ba8c58308ff05e30d9dbdc7c15028bca111/mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62", size = 10063996 }, - { url = "https://files.pythonhosted.org/packages/d1/1f/6b76be289a5a521bb1caedc1f08e76ff17ab59061007f201a8a18cc514d1/mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8", size = 12584043 }, - { url = "https://files.pythonhosted.org/packages/a6/83/5a85c9a5976c6f96e3a5a7591aa28b4a6ca3a07e9e5ba0cec090c8b596d6/mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7", size = 13036996 }, - { url = "https://files.pythonhosted.org/packages/3b/86/72ce7f57431d87a7ff17d442f521146a6585019eb8f4f31b7c02801f78ad/mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a", size = 2647043 }, + { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" }, + { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" }, + { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" }, + { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" }, ] [[package]] name = "mypy-extensions" -version = "1.0.0" +version = "1.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] [[package]] name = "myst-parser" -version = "4.0.0" +version = "4.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "docutils", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2037,18 +1286,18 @@ dependencies = [ { name = "pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/85/55/6d1741a1780e5e65038b74bce6689da15f620261c490c3511eb4c12bac4b/myst_parser-4.0.0.tar.gz", hash = "sha256:851c9dfb44e36e56d15d05e72f02b80da21a9e0d07cba96baf5e2d476bb91531", size = 93858 } +sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl", hash = "sha256:b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", size = 84563 }, + { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" }, ] [[package]] name = "objprint" version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/81/b8/c10e96120f1585824a1992655334b49da3924edfb364e84a26cc0ecdb89b/objprint-0.3.0.tar.gz", hash = "sha256:b5d83f9d62db5b95353bb42959106e1cd43010dcaa3eed1ad8d7d0b2df9b2d5a", size = 47481 } +sdist = { url = "https://files.pythonhosted.org/packages/81/b8/c10e96120f1585824a1992655334b49da3924edfb364e84a26cc0ecdb89b/objprint-0.3.0.tar.gz", hash = "sha256:b5d83f9d62db5b95353bb42959106e1cd43010dcaa3eed1ad8d7d0b2df9b2d5a", size = 47481, upload-time = "2024-11-09T00:05:16.73Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/af/572825252f16f36eeecbc8e3b721913d2640d69b984fdb8907aa8b4b0975/objprint-0.3.0-py3-none-any.whl", hash = "sha256:489083bfc8baf0526f8fd6af74673799511532636f0ce4141133255ded773405", size = 41619 }, + { url = "https://files.pythonhosted.org/packages/ec/af/572825252f16f36eeecbc8e3b721913d2640d69b984fdb8907aa8b4b0975/objprint-0.3.0-py3-none-any.whl", hash = "sha256:489083bfc8baf0526f8fd6af74673799511532636f0ce4141133255ded773405", size = 41619, upload-time = "2024-11-09T00:05:14.852Z" }, ] [[package]] @@ -2058,57 +1307,57 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "et-xmlfile", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464 } +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910 }, + { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" }, ] [[package]] name = "opentelemetry-api" -version = "1.29.0" +version = "1.39.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "deprecated", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "importlib-metadata", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bc/8e/b886a5e9861afa188d1fe671fb96ff9a1d90a23d57799331e137cc95d573/opentelemetry_api-1.29.0.tar.gz", hash = "sha256:d04a6cf78aad09614f52964ecb38021e248f5714dc32c2e0d8fd99517b4d69cf", size = 62900 } +sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/43/53/5249ea860d417a26a3a6f1bdedfc0748c4f081a3adaec3d398bc0f7c6a71/opentelemetry_api-1.29.0-py3-none-any.whl", hash = "sha256:5fcd94c4141cc49c736271f3e1efb777bebe9cc535759c54c936cca4f1b312b8", size = 64304 }, + { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" }, ] [[package]] name = "opentelemetry-exporter-otlp-proto-common" -version = "1.29.0" +version = "1.39.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-proto", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/58/f7fd7eaf592b2521999a4271ab3ce1c82fe37fe9b0dc25c348398d95d66a/opentelemetry_exporter_otlp_proto_common-1.29.0.tar.gz", hash = "sha256:e7c39b5dbd1b78fe199e40ddfe477e6983cb61aa74ba836df09c3869a3e3e163", size = 19133 } +sdist = { url = "https://files.pythonhosted.org/packages/e9/9d/22d241b66f7bbde88a3bfa6847a351d2c46b84de23e71222c6aae25c7050/opentelemetry_exporter_otlp_proto_common-1.39.1.tar.gz", hash = "sha256:763370d4737a59741c89a67b50f9e39271639ee4afc999dadfe768541c027464", size = 20409, upload-time = "2025-12-11T13:32:40.885Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/75/7609bda3d72bf307839570b226180513e854c01443ebe265ed732a4980fc/opentelemetry_exporter_otlp_proto_common-1.29.0-py3-none-any.whl", hash = "sha256:a9d7376c06b4da9cf350677bcddb9618ed4b8255c3f6476975f5e38274ecd3aa", size = 18459 }, + { url = "https://files.pythonhosted.org/packages/8c/02/ffc3e143d89a27ac21fd557365b98bd0653b98de8a101151d5805b5d4c33/opentelemetry_exporter_otlp_proto_common-1.39.1-py3-none-any.whl", hash = "sha256:08f8a5862d64cc3435105686d0216c1365dc5701f86844a8cd56597d0c764fde", size = 18366, upload-time = "2025-12-11T13:32:20.2Z" }, ] [[package]] name = "opentelemetry-exporter-otlp-proto-http" -version = "1.29.0" +version = "1.39.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "deprecated", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "googleapis-common-protos", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-exporter-otlp-proto-common", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-proto", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ab/88/e70a2e9fbb1bddb1ab7b6d74fb02c68601bff5948292ce33464c84ee082e/opentelemetry_exporter_otlp_proto_http-1.29.0.tar.gz", hash = "sha256:b10d174e3189716f49d386d66361fbcf6f2b9ad81e05404acdee3f65c8214204", size = 15041 } +sdist = { url = "https://files.pythonhosted.org/packages/80/04/2a08fa9c0214ae38880df01e8bfae12b067ec0793446578575e5080d6545/opentelemetry_exporter_otlp_proto_http-1.39.1.tar.gz", hash = "sha256:31bdab9745c709ce90a49a0624c2bd445d31a28ba34275951a6a362d16a0b9cb", size = 17288, upload-time = "2025-12-11T13:32:42.029Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/31/49/a1c3d24e8fe73b5f422e21b46c24aed3db7fd9427371c06442e7bdfe4d3b/opentelemetry_exporter_otlp_proto_http-1.29.0-py3-none-any.whl", hash = "sha256:b228bdc0f0cfab82eeea834a7f0ffdd2a258b26aa33d89fb426c29e8e934d9d0", size = 17217 }, + { url = "https://files.pythonhosted.org/packages/95/f1/b27d3e2e003cd9a3592c43d099d2ed8d0a947c15281bf8463a256db0b46c/opentelemetry_exporter_otlp_proto_http-1.39.1-py3-none-any.whl", hash = "sha256:d9f5207183dd752a412c4cd564ca8875ececba13be6e9c6c370ffb752fd59985", size = 19641, upload-time = "2025-12-11T13:32:22.248Z" }, ] [[package]] name = "opentelemetry-instrumentation" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2116,14 +1365,30 @@ dependencies = [ { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/79/2e/2e59a7cb636dc394bd7cf1758ada5e8ed87590458ca6bb2f9c26e0243847/opentelemetry_instrumentation-0.50b0.tar.gz", hash = "sha256:7d98af72de8dec5323e5202e46122e5f908592b22c6d24733aad619f07d82979", size = 26539 } +sdist = { url = "https://files.pythonhosted.org/packages/41/0f/7e6b713ac117c1f5e4e3300748af699b9902a2e5e34c9cf443dde25a01fa/opentelemetry_instrumentation-0.60b1.tar.gz", hash = "sha256:57ddc7974c6eb35865af0426d1a17132b88b2ed8586897fee187fd5b8944bd6a", size = 31706, upload-time = "2025-12-11T13:36:42.515Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/b1/55a77152a83ec8998e520a3a575f44af1020cfe4bdc000b7538583293b85/opentelemetry_instrumentation-0.50b0-py3-none-any.whl", hash = "sha256:b8f9fc8812de36e1c6dffa5bfc6224df258841fb387b6dfe5df15099daa10630", size = 30728 }, + { url = "https://files.pythonhosted.org/packages/77/d2/6788e83c5c86a2690101681aeef27eeb2a6bf22df52d3f263a22cee20915/opentelemetry_instrumentation-0.60b1-py3-none-any.whl", hash = "sha256:04480db952b48fb1ed0073f822f0ee26012b7be7c3eac1a3793122737c78632d", size = 33096, upload-time = "2025-12-11T13:35:33.067Z" }, +] + +[[package]] +name = "opentelemetry-instrumentation-asgi" +version = "0.60b1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "opentelemetry-instrumentation", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/db/851fa88db7441da82d50bd80f2de5ee55213782e25dc858e04d0c9961d60/opentelemetry_instrumentation_asgi-0.60b1.tar.gz", hash = "sha256:16bfbe595cd24cda309a957456d0fc2523f41bc7b076d1f2d7e98a1ad9876d6f", size = 26107, upload-time = "2025-12-11T13:36:47.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/76/1fb94367cef64420d2171157a6b9509582873bd09a6afe08a78a8d1f59d9/opentelemetry_instrumentation_asgi-0.60b1-py3-none-any.whl", hash = "sha256:d48def2dbed10294c99cfcf41ebbd0c414d390a11773a41f472d20000fcddc25", size = 16933, upload-time = "2025-12-11T13:35:40.462Z" }, ] [[package]] name = "opentelemetry-instrumentation-dbapi" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2131,14 +1396,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/94/f6f2c369f75e02c551dfa6ab5818e606f73eca2409930c467fcdb0e5634e/opentelemetry_instrumentation_dbapi-0.50b0.tar.gz", hash = "sha256:2603ca39e216893026c185ca8c44c326c0a9a763d5afff2309bd6195c50b7c49", size = 12613 } +sdist = { url = "https://files.pythonhosted.org/packages/94/b5/1e1f0642892a2abb6e75b7009ccee946e801cded88caac3d803cf46c8c73/opentelemetry_instrumentation_dbapi-0.60b1.tar.gz", hash = "sha256:a239d328249b86fba5e42900b98bf31ee99c07092530feca18afde92c600f901", size = 16311, upload-time = "2025-12-11T13:36:55.654Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0a/49/40def6cd71a6d248e9e48a731021cb9bfc70e5ec09986826ad29bd44b23c/opentelemetry_instrumentation_dbapi-0.50b0-py3-none-any.whl", hash = "sha256:23a730c3d7372b04b8a9507d2a67c5efbf92ff718eaa002b81ffbaf2b01d270f", size = 11533 }, + { url = "https://files.pythonhosted.org/packages/4e/08/d4c78b6e317d9975d473dd98f7854f5731ff4a1d470c65d2630fa68a1484/opentelemetry_instrumentation_dbapi-0.60b1-py3-none-any.whl", hash = "sha256:5577189f678de5b9828c930c8fb72e8f1999b304131777b60099e5c4b3948193", size = 13968, upload-time = "2025-12-11T13:35:56.316Z" }, ] [[package]] name = "opentelemetry-instrumentation-django" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2147,28 +1412,28 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/28/f2/ee600f366bc7712d476bc0bb0ac5efbc2b78e2620fc82b53795d4d9357c7/opentelemetry_instrumentation_django-0.50b0.tar.gz", hash = "sha256:624fd0beb1ac827f2af31709c2da5cb55d8dc899c2449d6e8fcc9fa5538fd56b", size = 24583 } +sdist = { url = "https://files.pythonhosted.org/packages/56/dc/a42fb5ff5c4ea8128d7c61a322e0cfbeae0fd204fc63a679f73caeec266e/opentelemetry_instrumentation_django-0.60b1.tar.gz", hash = "sha256:765b69c7ccdea7e9ebfd0b9e68387956b8f74816f3e39775d5b06a20f16b0522", size = 26599, upload-time = "2025-12-11T13:36:56.293Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/4c/30d88a823a0c08fbaa022e23e3ce1a3572a12cd3082e9d76d2988430a733/opentelemetry_instrumentation_django-0.50b0-py3-none-any.whl", hash = "sha256:ab7b4cd52b8f12420d968823f6bbfbc2a6ddb2af7a05fcb0d5b6755d338f1915", size = 19435 }, + { url = "https://files.pythonhosted.org/packages/bc/05/6b348ea989f7a9e1e6311fa653e113bd39f4506771323e27a639c2a1ea54/opentelemetry_instrumentation_django-0.60b1-py3-none-any.whl", hash = "sha256:3f6b4ba201eee35406dab965b254eed0c64fa1ef42e4a7b0296ad1b30e8e3f81", size = 21172, upload-time = "2025-12-11T13:35:57.365Z" }, ] [[package]] name = "opentelemetry-instrumentation-sqlite3" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-instrumentation", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-instrumentation-dbapi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/64/8a/9a39717588e121f98481561766d0002c41d96935c6ea2b54dd6b5581d1c7/opentelemetry_instrumentation_sqlite3-0.50b0.tar.gz", hash = "sha256:b7c98f7c72f01e3ca6751c2075eebbef8335fc08800ccdf1d97741207cdbe1ba", size = 7718 } +sdist = { url = "https://files.pythonhosted.org/packages/44/33/fafa354b529a7e9b5a5dc4155953bae1ff71622334a420d19f7e1d65e7cc/opentelemetry_instrumentation_sqlite3-0.60b1.tar.gz", hash = "sha256:d716b9d89d31dc426ccedefcdbf96cba1897dfe020d21e5e5ea82a782d03e1d6", size = 7922, upload-time = "2025-12-11T13:37:13.655Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/37/d2/0088c11c29e6942ab24910608ce2a416d2b5e76c3d29702578aadec97e52/opentelemetry_instrumentation_sqlite3-0.50b0-py3-none-any.whl", hash = "sha256:37e030bcc87733f769faf87c81c4de9dc932b74b565a1e19e7d13e17ec120901", size = 8938 }, + { url = "https://files.pythonhosted.org/packages/d8/64/be1c8a6d17cf2860f41206828cbabe39b71345cc95626b91c84f48e96066/opentelemetry_instrumentation_sqlite3-0.60b1-py3-none-any.whl", hash = "sha256:7666853b9df186b81e587320aaa03da3f1ce46ba9277b62d8ea20a745886031c", size = 9338, upload-time = "2025-12-11T13:36:25.854Z" }, ] [[package]] name = "opentelemetry-instrumentation-wsgi" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2176,75 +1441,84 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d0/cf/edb5335480d919b658aedf7c30f146e5f7edbd26558b0947e8668c8b23f3/opentelemetry_instrumentation_wsgi-0.50b0.tar.gz", hash = "sha256:c25b5f1b664d984a41546a34cf2f893dcde6cf56922f88c475864e7df37edf4a", size = 17720 } +sdist = { url = "https://files.pythonhosted.org/packages/6d/24/5632d31506a27650567fdff8f9be37fc4d98396b6331617be69bd332bf77/opentelemetry_instrumentation_wsgi-0.60b1.tar.gz", hash = "sha256:eb553eec7ebfcf2945cc10d787a265e7abadb9ed1d1ebce8b13988d44fa0cf45", size = 19167, upload-time = "2025-12-11T13:37:20.3Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/f5/a81147e2dd64f64942008bc65fc2f57f1b1123aeb8a0bf6ac8aab7a6fc48/opentelemetry_instrumentation_wsgi-0.50b0-py3-none-any.whl", hash = "sha256:4bc0fdf52b603507d6170a25504f0ceea358d7e90a2c0e8794b7b7eca5ea355c", size = 13678 }, + { url = "https://files.pythonhosted.org/packages/93/98/c637d9e5cab1355d6765de2304199a1d79a43aa94c33d8eddb475327d81a/opentelemetry_instrumentation_wsgi-0.60b1-py3-none-any.whl", hash = "sha256:5e7b432778ebf5a39af136227884a6ab2efc3c4e73e2dbb1d05ecf03ea196705", size = 14583, upload-time = "2025-12-11T13:36:33.164Z" }, ] [[package]] name = "opentelemetry-proto" -version = "1.29.0" +version = "1.39.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/80/52/fd3b3d79e1b00ad2dcac92db6885e49bedbf7a6828647954e4952d653132/opentelemetry_proto-1.29.0.tar.gz", hash = "sha256:3c136aa293782e9b44978c738fff72877a4b78b5d21a64e879898db7b2d93e5d", size = 34320 } +sdist = { url = "https://files.pythonhosted.org/packages/49/1d/f25d76d8260c156c40c97c9ed4511ec0f9ce353f8108ca6e7561f82a06b2/opentelemetry_proto-1.39.1.tar.gz", hash = "sha256:6c8e05144fc0d3ed4d22c2289c6b126e03bcd0e6a7da0f16cedd2e1c2772e2c8", size = 46152, upload-time = "2025-12-11T13:32:48.681Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/66/a500e38ee322d89fce61c74bd7769c8ef3bebc6c2f43fda5f3fc3441286d/opentelemetry_proto-1.29.0-py3-none-any.whl", hash = "sha256:495069c6f5495cbf732501cdcd3b7f60fda2b9d3d4255706ca99b7ca8dec53ff", size = 55818 }, + { url = "https://files.pythonhosted.org/packages/51/95/b40c96a7b5203005a0b03d8ce8cd212ff23f1793d5ba289c87a097571b18/opentelemetry_proto-1.39.1-py3-none-any.whl", hash = "sha256:22cdc78efd3b3765d09e68bfbd010d4fc254c9818afd0b6b423387d9dee46007", size = 72535, upload-time = "2025-12-11T13:32:33.866Z" }, ] [[package]] name = "opentelemetry-sdk" -version = "1.29.0" +version = "1.39.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0c/5a/1ed4c3cf6c09f80565fc085f7e8efa0c222712fd2a9412d07424705dcf72/opentelemetry_sdk-1.29.0.tar.gz", hash = "sha256:b0787ce6aade6ab84315302e72bd7a7f2f014b0fb1b7c3295b88afe014ed0643", size = 157229 } +sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/1d/512b86af21795fb463726665e2f61db77d384e8779fdcf4cb0ceec47866d/opentelemetry_sdk-1.29.0-py3-none-any.whl", hash = "sha256:173be3b5d3f8f7d671f20ea37056710217959e774e2749d984355d1f9391a30a", size = 118078 }, + { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" }, ] [[package]] name = "opentelemetry-semantic-conventions" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "deprecated", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e7/4e/d7c7c91ff47cd96fe4095dd7231701aec7347426fd66872ff320d6cd1fcc/opentelemetry_semantic_conventions-0.50b0.tar.gz", hash = "sha256:02dc6dbcb62f082de9b877ff19a3f1ffaa3c306300fa53bfac761c4567c83d38", size = 100459 } +sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/da/fb/dc15fad105450a015e913cfa4f5c27b6a5f1bea8fb649f8cae11e699c8af/opentelemetry_semantic_conventions-0.50b0-py3-none-any.whl", hash = "sha256:e87efba8fdb67fb38113efea6a349531e75ed7ffc01562f65b802fcecb5e115e", size = 166602 }, + { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" }, ] [[package]] name = "opentelemetry-util-http" -version = "0.50b0" +version = "0.60b1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/69/10/ce3f0d1157cedbd819194f0b27a6bbb7c19a8bceb3941e4a4775014076cf/opentelemetry_util_http-0.50b0.tar.gz", hash = "sha256:dc4606027e1bc02aabb9533cc330dd43f874fca492e4175c31d7154f341754af", size = 7859 } +sdist = { url = "https://files.pythonhosted.org/packages/50/fc/c47bb04a1d8a941a4061307e1eddfa331ed4d0ab13d8a9781e6db256940a/opentelemetry_util_http-0.60b1.tar.gz", hash = "sha256:0d97152ca8c8a41ced7172d29d3622a219317f74ae6bb3027cfbdcf22c3cc0d6", size = 11053, upload-time = "2025-12-11T13:37:25.115Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/64/8a/9e1b54f50d1fddebbeac9a9b0632f8db6ece7add904fb593ee2e268ee4de/opentelemetry_util_http-0.50b0-py3-none-any.whl", hash = "sha256:21f8aedac861ffa3b850f8c0a6c373026189eb8630ac6e14a2bf8c55695cc090", size = 6942 }, + { url = "https://files.pythonhosted.org/packages/16/5c/d3f1733665f7cd582ef0842fb1d2ed0bc1fba10875160593342d22bba375/opentelemetry_util_http-0.60b1-py3-none-any.whl", hash = "sha256:66381ba28550c91bee14dcba8979ace443444af1ed609226634596b4b0faf199", size = 8947, upload-time = "2025-12-11T13:36:37.151Z" }, ] [[package]] name = "packaging" -version = "24.2" +version = "25.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, ] [[package]] name = "parso" -version = "0.8.4" +version = "0.8.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, + { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, ] [[package]] @@ -2254,45 +1528,45 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ptyprocess", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, ] [[package]] name = "phonenumbers" -version = "8.13.52" +version = "9.0.21" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2f/be/8d1698beaed180df58685a3d0e1aacac86a7b90e74a954ca489bd2a0a247/phonenumbers-8.13.52.tar.gz", hash = "sha256:fdc371ea6a4da052beb1225de63963d5a2fddbbff2bb53e3a957f360e0185f80", size = 2296342 } +sdist = { url = "https://files.pythonhosted.org/packages/df/c9/15e160ae4a8a34c93a8eddd930b0a801e8826cf4df3586f19d46809e60b4/phonenumbers-9.0.21.tar.gz", hash = "sha256:df4145cba0a8b3ee9c425d5d9b5dbe1b4fceccc68b030ac549ea13c95592b602", size = 2297827, upload-time = "2025-12-18T07:37:26.495Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/fa/ccc322224bbe27434f67d8fae917affcf6af4a6ef55f82f16ae87d9c784d/phonenumbers-8.13.52-py2.py3-none-any.whl", hash = "sha256:e803210038ece9d208b129e3023dc20e656a820d6bf6f1cb0471d4164f54bada", size = 2582018 }, + { url = "https://files.pythonhosted.org/packages/37/71/364ea74338bde467bec6b6b0ab33b5ced57e473dfb427b96cc78da8e6af4/phonenumbers-9.0.21-py2.py3-none-any.whl", hash = "sha256:3a0f717fddf901a5a424f47c43fb72722cb45bd25ee87331987b00eafe6855bf", size = 2584216, upload-time = "2025-12-18T07:37:24.539Z" }, ] [[package]] name = "pip" -version = "24.3.1" +version = "25.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f4/b1/b422acd212ad7eedddaf7981eee6e5de085154ff726459cf2da7c5a184c1/pip-24.3.1.tar.gz", hash = "sha256:ebcb60557f2aefabc2e0f918751cd24ea0d56d8ec5445fe1807f1d2109660b99", size = 1931073 } +sdist = { url = "https://files.pythonhosted.org/packages/fe/6e/74a3f0179a4a73a53d66ce57fdb4de0080a8baa1de0063de206d6167acc2/pip-25.3.tar.gz", hash = "sha256:8d0538dbbd7babbd207f261ed969c65de439f6bc9e5dbd3b3b9a77f25d95f343", size = 1803014, upload-time = "2025-10-25T00:55:41.394Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/7d/500c9ad20238fcfcb4cb9243eede163594d7020ce87bd9610c9e02771876/pip-24.3.1-py3-none-any.whl", hash = "sha256:3790624780082365f47549d032f3770eeb2b1e8bd1f7b2e02dace1afa361b4ed", size = 1822182 }, + { url = "https://files.pythonhosted.org/packages/44/3c/d717024885424591d5376220b5e836c2d5293ce2011523c9de23ff7bf068/pip-25.3-py3-none-any.whl", hash = "sha256:9655943313a94722b7774661c21049070f6bbb0a1516bf02f7c8d5d9201514cd", size = 1778622, upload-time = "2025-10-25T00:55:39.247Z" }, ] [[package]] name = "platformdirs" -version = "4.3.6" +version = "4.5.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 } +sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 }, + { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" }, ] [[package]] name = "pluggy" -version = "1.5.0" +version = "1.6.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +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" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, + { 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" }, ] [[package]] @@ -2302,259 +1576,244 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/57/b6/cd79a0e237e733e2f8a196f4e9f4d30d99c769b809c5fbbea9e34400655d/pocket-0.3.6.tar.gz", hash = "sha256:907bf16a19fae9c2080f799d979de4c8daa36d6d28e86ceb9fc17d6f0bdb89b9", size = 3749 } +sdist = { url = "https://files.pythonhosted.org/packages/57/b6/cd79a0e237e733e2f8a196f4e9f4d30d99c769b809c5fbbea9e34400655d/pocket-0.3.6.tar.gz", hash = "sha256:907bf16a19fae9c2080f799d979de4c8daa36d6d28e86ceb9fc17d6f0bdb89b9", size = 3749, upload-time = "2015-07-26T10:06:51.889Z" } [[package]] name = "prompt-toolkit" -version = "3.0.48" +version = "3.0.52" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "wcwidth", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2d/4f/feb5e137aff82f7c7f3248267b97451da3644f6cdc218edfe549fb354127/prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90", size = 424684 } +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/6a/fd08d94654f7e67c52ca30523a178b3f8ccc4237fce4be90d39c938a831a/prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e", size = 386595 }, + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, ] [[package]] name = "protobuf" -version = "5.29.2" +version = "6.33.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a5/73/4e6295c1420a9d20c9c351db3a36109b4c9aa601916cb7c6871e3196a1ca/protobuf-5.29.2.tar.gz", hash = "sha256:b2cc8e8bb7c9326996f0e160137b0861f1a82162502658df2951209d0cb0309e", size = 424901 } +sdist = { url = "https://files.pythonhosted.org/packages/34/44/e49ecff446afeec9d1a66d6bbf9adc21e3c7cea7803a920ca3773379d4f6/protobuf-6.33.2.tar.gz", hash = "sha256:56dc370c91fbb8ac85bc13582c9e373569668a290aa2e66a590c2a0d35ddb9e4", size = 444296, upload-time = "2025-12-06T00:17:53.311Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/26/41debe0f6615fcb7e97672057524687ed86fcd85e3da3f031c30af8f0c51/protobuf-5.29.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a0c53d78383c851bfa97eb42e3703aefdc96d2036a41482ffd55dc5f529466eb", size = 417812 }, - { url = "https://files.pythonhosted.org/packages/e4/20/38fc33b60dcfb380507b99494aebe8c34b68b8ac7d32808c4cebda3f6f6b/protobuf-5.29.2-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:494229ecd8c9009dd71eda5fd57528395d1eacdf307dbece6c12ad0dd09e912e", size = 319562 }, - { url = "https://files.pythonhosted.org/packages/90/4d/c3d61e698e0e41d926dbff6aa4e57428ab1a6fc3b5e1deaa6c9ec0fd45cf/protobuf-5.29.2-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:b6b0d416bbbb9d4fbf9d0561dbfc4e324fd522f61f7af0fe0f282ab67b22477e", size = 319662 }, - { url = "https://files.pythonhosted.org/packages/f3/fd/c7924b4c2a1c61b8f4b64edd7a31ffacf63432135a2606f03a2f0d75a750/protobuf-5.29.2-py3-none-any.whl", hash = "sha256:fde4554c0e578a5a0bcc9a276339594848d1e89f9ea47b4427c80e5d72f90181", size = 172539 }, + { url = "https://files.pythonhosted.org/packages/b2/ca/7e485da88ba45c920fb3f50ae78de29ab925d9e54ef0de678306abfbb497/protobuf-6.33.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d9b19771ca75935b3a4422957bc518b0cecb978b31d1dd12037b088f6bcc0e43", size = 427621, upload-time = "2025-12-06T00:17:44.445Z" }, + { url = "https://files.pythonhosted.org/packages/7d/4f/f743761e41d3b2b2566748eb76bbff2b43e14d5fcab694f494a16458b05f/protobuf-6.33.2-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:b5d3b5625192214066d99b2b605f5783483575656784de223f00a8d00754fc0e", size = 324460, upload-time = "2025-12-06T00:17:45.678Z" }, + { url = "https://files.pythonhosted.org/packages/b1/fa/26468d00a92824020f6f2090d827078c09c9c587e34cbfd2d0c7911221f8/protobuf-6.33.2-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8cd7640aee0b7828b6d03ae518b5b4806fdfc1afe8de82f79c3454f8aef29872", size = 339168, upload-time = "2025-12-06T00:17:46.813Z" }, + { url = "https://files.pythonhosted.org/packages/56/13/333b8f421738f149d4fe5e49553bc2a2ab75235486259f689b4b91f96cec/protobuf-6.33.2-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:1f8017c48c07ec5859106533b682260ba3d7c5567b1ca1f24297ce03384d1b4f", size = 323270, upload-time = "2025-12-06T00:17:48.253Z" }, + { url = "https://files.pythonhosted.org/packages/0e/15/4f02896cc3df04fc465010a4c6a0cd89810f54617a32a70ef531ed75d61c/protobuf-6.33.2-py3-none-any.whl", hash = "sha256:7636aad9bb01768870266de5dc009de2d1b936771b38a793f73cbbf279c91c5c", size = 170501, upload-time = "2025-12-06T00:17:52.211Z" }, ] [[package]] name = "psutil" -version = "6.1.0" +version = "7.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/26/10/2a30b13c61e7cf937f4adf90710776b7918ed0a9c434e2c38224732af310/psutil-6.1.0.tar.gz", hash = "sha256:353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a", size = 508565 } +sdist = { url = "https://files.pythonhosted.org/packages/be/7c/31d1c3ceb1260301f87565f50689dc6da3db427ece1e1e012af22abca54e/psutil-7.2.0.tar.gz", hash = "sha256:2e4f8e1552f77d14dc96fb0f6240c5b34a37081c0889f0853b3b29a496e5ef64", size = 489863, upload-time = "2025-12-23T20:26:24.616Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/01/9e/8be43078a171381953cfee33c07c0d628594b5dbfc5157847b85022c2c1b/psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688", size = 247762 }, - { url = "https://files.pythonhosted.org/packages/1d/cb/313e80644ea407f04f6602a9e23096540d9dc1878755f3952ea8d3d104be/psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e", size = 248777 }, - { url = "https://files.pythonhosted.org/packages/65/8e/bcbe2025c587b5d703369b6a75b65d41d1367553da6e3f788aff91eaf5bd/psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38", size = 284259 }, - { url = "https://files.pythonhosted.org/packages/58/4d/8245e6f76a93c98aab285a43ea71ff1b171bcd90c9d238bf81f7021fb233/psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b", size = 287255 }, - { url = "https://files.pythonhosted.org/packages/27/c2/d034856ac47e3b3cdfa9720d0e113902e615f4190d5d1bdb8df4b2015fb2/psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a", size = 288804 }, + { url = "https://files.pythonhosted.org/packages/44/86/98da45dff471b93ef5ce5bcaefa00e3038295a7880a77cf74018243d37fb/psutil-7.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2f2f53fd114e7946dfba3afb98c9b7c7f376009447360ca15bfb73f2066f84c7", size = 129692, upload-time = "2025-12-23T20:26:40.623Z" }, + { url = "https://files.pythonhosted.org/packages/50/ee/10eae91ba4ad071c92db3c178ba861f30406342de9f0ddbe6d51fd741236/psutil-7.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e65c41d7e60068f60ce43b31a3a7fc90deb0dfd34ffc824a2574c2e5279b377e", size = 130110, upload-time = "2025-12-23T20:26:42.569Z" }, + { url = "https://files.pythonhosted.org/packages/87/3a/2b2897443d56fedbbc34ac68a0dc7d55faa05d555372a2f989109052f86d/psutil-7.2.0-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc66d21366850a4261412ce994ae9976bba9852dafb4f2fa60db68ed17ff5281", size = 181487, upload-time = "2025-12-23T20:26:44.633Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/44308428f7333db42c5ea7390c52af1b38f59b80b80c437291f58b5dfdad/psutil-7.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e025d67b42b8f22b096d5d20f5171de0e0fefb2f0ce983a13c5a1b5ed9872706", size = 184320, upload-time = "2025-12-23T20:26:46.83Z" }, + { url = "https://files.pythonhosted.org/packages/40/c5/a49160bf3e165b7b93a60579a353cf5d939d7f878fe5fd369110f1d18043/psutil-7.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:977a2fcd132d15cb05b32b2d85b98d087cad039b0ce435731670ba74da9e6133", size = 128116, upload-time = "2025-12-23T20:26:53.516Z" }, + { url = "https://files.pythonhosted.org/packages/10/a1/c75feb480f60cd768fb6ed00ac362a16a33e5076ec8475a22d8162fb2659/psutil-7.2.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:24151011c21fadd94214d7139d7c6c54569290d7e553989bdf0eab73b13beb8c", size = 128925, upload-time = "2025-12-23T20:26:55.573Z" }, + { url = "https://files.pythonhosted.org/packages/12/ff/e93136587c00a543f4bc768b157fac2c47cd77b180d4f4e5c6efb6ea53a2/psutil-7.2.0-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91f211ba9279e7c61d9d8f84b713cfc38fa161cb0597d5cb3f1ca742f6848254", size = 154666, upload-time = "2025-12-23T20:26:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/b8/dd/4c2de9c3827c892599d277a69d2224136800870a8a88a80981de905de28d/psutil-7.2.0-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f37415188b7ea98faf90fed51131181646c59098b077550246e2e092e127418b", size = 156109, upload-time = "2025-12-23T20:26:58.851Z" }, + { url = "https://files.pythonhosted.org/packages/81/3f/090943c682d3629968dd0b04826ddcbc760ee1379021dbe316e2ddfcd01b/psutil-7.2.0-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0d12c7ce6ed1128cd81fd54606afa054ac7dbb9773469ebb58cf2f171c49f2ac", size = 148081, upload-time = "2025-12-23T20:27:01.318Z" }, + { url = "https://files.pythonhosted.org/packages/c4/88/c39648ebb8ec182d0364af53cdefe6eddb5f3872ba718b5855a8ff65d6d4/psutil-7.2.0-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ca0faef7976530940dcd39bc5382d0d0d5eb023b186a4901ca341bd8d8684151", size = 147376, upload-time = "2025-12-23T20:27:03.347Z" }, ] [[package]] name = "ptyprocess" version = "0.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, ] [[package]] name = "pure-eval" version = "0.2.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, ] [[package]] name = "py-machineid" -version = "0.7.0" +version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/10/2c/fd1764547506819eca1e849865b5f64268f37bc48c03433af379ad2faeed/py-machineid-0.7.0.tar.gz", hash = "sha256:5a74a810e38b57b043b145c756c1e6ac161529cb7d83fe20099fcb986acc577b", size = 4587 } +sdist = { url = "https://files.pythonhosted.org/packages/f4/b0/c7fa6de7298a8f4e544929b97fa028304c0e11a4bc9500eff8689821bdbb/py_machineid-1.0.0.tar.gz", hash = "sha256:8a902a00fae8c6d6433f463697c21dc4ce98c6e55a2e0535c0273319acb0047a", size = 4629, upload-time = "2025-12-02T16:12:54.286Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/ce/7e0f98cd38efee0da8cfb2e50ac825c3df240f57364f87c225ad8ef04223/py_machineid-0.7.0-py3-none-any.whl", hash = "sha256:3dacc322b0511383d79f1e817a2710b19bcfb820a4c7cea34aaa329775fef468", size = 4892 }, + { url = "https://files.pythonhosted.org/packages/be/76/1ed8375cb1212824c57eb706e1f09f3f2ca4ed12b8d56b28a160e2d53505/py_machineid-1.0.0-py3-none-any.whl", hash = "sha256:910df0d5f2663bcf6739d835c4949f4e9cc6bb090a58b3dd766e12e5f768e3b9", size = 4926, upload-time = "2025-12-02T16:12:20.584Z" }, ] +[[package]] +name = "py-ubjson" +version = "0.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/c7/28220d37e041fe1df03e857fe48f768dcd30cd151480bf6f00da8713214a/py-ubjson-0.16.1.tar.gz", hash = "sha256:b9bfb8695a1c7e3632e800fb83c943bf67ed45ddd87cd0344851610c69a5a482", size = 50316, upload-time = "2020-04-18T15:05:57.698Z" } + [[package]] name = "pyasn1" version = "0.6.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322 } +sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload-time = "2024-09-10T22:41:42.55Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135 }, + { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload-time = "2024-09-11T16:00:36.122Z" }, ] [[package]] name = "pyasn1-modules" -version = "0.4.1" +version = "0.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyasn1", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1d/67/6afbf0d507f73c32d21084a79946bfcfca5fbc62a72057e9c23797a737c9/pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c", size = 310028 } +sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/89/bc88a6711935ba795a679ea6ebee07e128050d6382eaa35a0a47c8032bdc/pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd", size = 181537 }, + { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" }, ] [[package]] name = "pycodestyle" -version = "2.12.1" +version = "2.14.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/aa/210b2c9aedd8c1cbeea31a50e42050ad56187754b34eb214c46709445801/pycodestyle-2.12.1.tar.gz", hash = "sha256:6838eae08bbce4f6accd5d5572075c63626a15ee3e6f842df996bf62f6d73521", size = 39232 } +sdist = { url = "https://files.pythonhosted.org/packages/11/e0/abfd2a0d2efe47670df87f3e3a0e2edda42f055053c85361f19c0e2c1ca8/pycodestyle-2.14.0.tar.gz", hash = "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783", size = 39472, upload-time = "2025-06-20T18:49:48.75Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/d8/a211b3f85e99a0daa2ddec96c949cac6824bd305b040571b82a03dd62636/pycodestyle-2.12.1-py2.py3-none-any.whl", hash = "sha256:46f0fb92069a7c28ab7bb558f05bfc0110dac69a0cd23c61ea0040283a9d78b3", size = 31284 }, + { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" }, ] [[package]] name = "pycparser" -version = "2.22" +version = "2.23" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, ] [[package]] name = "pydantic" -version = "2.10.4" +version = "2.12.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-types", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pydantic-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-inspection", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/70/7e/fb60e6fee04d0ef8f15e4e01ff187a196fa976eb0f0ab524af4599e5754c/pydantic-2.10.4.tar.gz", hash = "sha256:82f12e9723da6de4fe2ba888b5971157b3be7ad914267dea8f05f82b28254f06", size = 762094 } +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f3/26/3e1bbe954fde7ee22a6e7d31582c642aad9e84ffe4b5fb61e63b87cd326f/pydantic-2.10.4-py3-none-any.whl", hash = "sha256:597e135ea68be3a37552fb524bc7d0d66dcf93d395acd93a00682f1efcb8ee3d", size = 431765 }, + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, ] [[package]] name = "pydantic-core" -version = "2.27.2" +version = "2.41.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 } +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/bc/fed5f74b5d802cf9a03e83f60f18864e90e3aed7223adaca5ffb7a8d8d64/pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa", size = 1895938 }, - { url = "https://files.pythonhosted.org/packages/71/2a/185aff24ce844e39abb8dd680f4e959f0006944f4a8a0ea372d9f9ae2e53/pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c", size = 1815684 }, - { url = "https://files.pythonhosted.org/packages/c3/43/fafabd3d94d159d4f1ed62e383e264f146a17dd4d48453319fd782e7979e/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a", size = 1829169 }, - { url = "https://files.pythonhosted.org/packages/a2/d1/f2dfe1a2a637ce6800b799aa086d079998959f6f1215eb4497966efd2274/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5", size = 1867227 }, - { url = "https://files.pythonhosted.org/packages/7d/39/e06fcbcc1c785daa3160ccf6c1c38fea31f5754b756e34b65f74e99780b5/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c", size = 2037695 }, - { url = "https://files.pythonhosted.org/packages/7a/67/61291ee98e07f0650eb756d44998214231f50751ba7e13f4f325d95249ab/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7", size = 2741662 }, - { url = "https://files.pythonhosted.org/packages/32/90/3b15e31b88ca39e9e626630b4c4a1f5a0dfd09076366f4219429e6786076/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a", size = 1993370 }, - { url = "https://files.pythonhosted.org/packages/ff/83/c06d333ee3a67e2e13e07794995c1535565132940715931c1c43bfc85b11/pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236", size = 1996813 }, - { url = "https://files.pythonhosted.org/packages/7c/f7/89be1c8deb6e22618a74f0ca0d933fdcb8baa254753b26b25ad3acff8f74/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962", size = 2005287 }, - { url = "https://files.pythonhosted.org/packages/b7/7d/8eb3e23206c00ef7feee17b83a4ffa0a623eb1a9d382e56e4aa46fd15ff2/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9", size = 2128414 }, - { url = "https://files.pythonhosted.org/packages/4e/99/fe80f3ff8dd71a3ea15763878d464476e6cb0a2db95ff1c5c554133b6b83/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af", size = 2155301 }, - { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 }, - { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 }, - { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 }, - { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 }, - { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 }, - { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 }, - { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 }, - { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 }, - { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 }, - { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 }, - { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 }, - { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 }, - { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 }, - { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 }, - { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 }, - { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 }, - { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 }, - { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 }, - { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 }, - { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 }, - { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 }, - { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 }, - { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 }, - { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 }, - { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 }, - { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 }, - { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 }, - { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 }, - { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 }, - { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 }, - { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 }, - { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 }, - { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 }, - { url = "https://files.pythonhosted.org/packages/46/72/af70981a341500419e67d5cb45abe552a7c74b66326ac8877588488da1ac/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e", size = 1891159 }, - { url = "https://files.pythonhosted.org/packages/ad/3d/c5913cccdef93e0a6a95c2d057d2c2cba347815c845cda79ddd3c0f5e17d/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8", size = 1768331 }, - { url = "https://files.pythonhosted.org/packages/f6/f0/a3ae8fbee269e4934f14e2e0e00928f9346c5943174f2811193113e58252/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3", size = 1822467 }, - { url = "https://files.pythonhosted.org/packages/d7/7a/7bbf241a04e9f9ea24cd5874354a83526d639b02674648af3f350554276c/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f", size = 1979797 }, - { url = "https://files.pythonhosted.org/packages/4f/5f/4784c6107731f89e0005a92ecb8a2efeafdb55eb992b8e9d0a2be5199335/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133", size = 1987839 }, - { url = "https://files.pythonhosted.org/packages/6d/a7/61246562b651dff00de86a5f01b6e4befb518df314c54dec187a78d81c84/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc", size = 1998861 }, - { url = "https://files.pythonhosted.org/packages/86/aa/837821ecf0c022bbb74ca132e117c358321e72e7f9702d1b6a03758545e2/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50", size = 2116582 }, - { url = "https://files.pythonhosted.org/packages/81/b0/5e74656e95623cbaa0a6278d16cf15e10a51f6002e3ec126541e95c29ea3/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9", size = 2151985 }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, ] [[package]] name = "pydantic-settings" -version = "2.7.0" +version = "2.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "python-dotenv", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-inspection", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/41/19b62b99e7530cfa1d6ccd16199afd9289a12929bef1a03aa4382b22e683/pydantic_settings-2.7.0.tar.gz", hash = "sha256:ac4bfd4a36831a48dbf8b2d9325425b549a0a6f18cea118436d728eb4f1c4d66", size = 79743 } +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/00/57b4540deb5c3a39ba689bb519a4e03124b24ab8589e618be4aac2c769bd/pydantic_settings-2.7.0-py3-none-any.whl", hash = "sha256:e00c05d5fa6cbbb227c84bd7487c5c1065084119b750df7c8c1a554aed236eb5", size = 29549 }, + { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" }, ] [[package]] name = "pyflakes" -version = "3.2.0" +version = "3.4.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/57/f9/669d8c9c86613c9d568757c7f5824bd3197d7b1c6c27553bc5618a27cce2/pyflakes-3.2.0.tar.gz", hash = "sha256:1c61603ff154621fb2a9172037d84dca3500def8c8b630657d1701f026f8af3f", size = 63788 } +sdist = { url = "https://files.pythonhosted.org/packages/45/dc/fd034dc20b4b264b3d015808458391acbf9df40b1e54750ef175d39180b1/pyflakes-3.4.0.tar.gz", hash = "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58", size = 64669, upload-time = "2025-06-20T18:45:27.834Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d4/d7/f1b7db88d8e4417c5d47adad627a93547f44bdc9028372dbd2313f34a855/pyflakes-3.2.0-py2.py3-none-any.whl", hash = "sha256:84b5be138a2dfbb40689ca07e2152deb896a65c3a3e24c251c5c62489568074a", size = 62725 }, + { url = "https://files.pythonhosted.org/packages/c2/2f/81d580a0fb83baeb066698975cb14a618bdbed7720678566f1b046a95fe8/pyflakes-3.4.0-py2.py3-none-any.whl", hash = "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f", size = 63551, upload-time = "2025-06-20T18:45:26.937Z" }, ] [[package]] name = "pygments" -version = "2.18.0" +version = "2.19.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", size = 4891905 } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", size = 1205513 }, + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] [[package]] name = "pyopenssl" -version = "24.3.0" +version = "25.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cryptography", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c1/d4/1067b82c4fc674d6f6e9e8d26b3dff978da46d351ca3bac171544693e085/pyopenssl-24.3.0.tar.gz", hash = "sha256:49f7a019577d834746bc55c5fce6ecbcec0f2b4ec5ce1cf43a9a173b8138bb36", size = 178944 } +sdist = { url = "https://files.pythonhosted.org/packages/80/be/97b83a464498a79103036bc74d1038df4a7ef0e402cfaf4d5e113fb14759/pyopenssl-25.3.0.tar.gz", hash = "sha256:c981cb0a3fd84e8602d7afc209522773b94c1c2446a3c710a75b06fe1beae329", size = 184073, upload-time = "2025-09-17T00:32:21.037Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/42/22/40f9162e943f86f0fc927ebc648078be87def360d9d8db346619fb97df2b/pyOpenSSL-24.3.0-py3-none-any.whl", hash = "sha256:e474f5a473cd7f92221cc04976e48f4d11502804657a08a989fb3be5514c904a", size = 56111 }, + { url = "https://files.pythonhosted.org/packages/d1/81/ef2b1dfd1862567d573a4fdbc9f969067621764fbb74338496840a1d2977/pyopenssl-25.3.0-py3-none-any.whl", hash = "sha256:1fda6fc034d5e3d179d39e59c1895c9faeaf40a79de5fc4cbbfbe0d36f4a77b6", size = 57268, upload-time = "2025-09-17T00:32:19.474Z" }, ] [[package]] name = "pytest" -version = "8.3.4" +version = "9.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "exceptiongroup", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, { name = "iniconfig", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pluggy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, + { name = "pygments", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, ] [[package]] name = "python-benedict" -version = "0.34.0" +version = "0.35.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "python-fsutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "python-slugify", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "useful-types", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7a/55/a16714b67dc05773722766b81495379279a2e65b9aa613701fe1c6832a90/python_benedict-0.34.0.tar.gz", hash = "sha256:d26a59abf418400dea39785d1336f5958fd7f00a732d5cc4e0e233a94e0b2c70", size = 53249 } +sdist = { url = "https://files.pythonhosted.org/packages/bc/7f/670cea45a5de7ba79b820b9e58c19ec28070e65f8fe4584edc14b3b86ff2/python_benedict-0.35.0.tar.gz", hash = "sha256:ca825742cb60641939857417b799c6ca6680ba1ed7d3a92cf722103bc8dcb3ea", size = 58486, upload-time = "2025-09-30T22:57:42.206Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ea/06/dad5bf034c5cc1ec4ff4de555a0a60030b007654b20579eb5bbfa5cd2171/python_benedict-0.34.0-py3-none-any.whl", hash = "sha256:acdcd993ecf56640a3bcd935086e1c19482271950933995511d1fd16a5954ece", size = 51280 }, + { url = "https://files.pythonhosted.org/packages/b6/ae/76f758e10b04c00f26c1613d8c77a078a3001d8ec439ec9e992d7c5a9268/python_benedict-0.35.0-py3-none-any.whl", hash = "sha256:4be33761812a2b8986b19f9dcb9df687feefd81c4cbb11becd044a5e28c340f6", size = 59905, upload-time = "2025-09-30T22:57:40.637Z" }, ] [package.optional-dependencies] @@ -2575,14 +1834,11 @@ parse = [ [[package]] name = "python-crontab" -version = "3.2.0" +version = "3.3.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "python-dateutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e2/f0/25775565c133d4e29eeb607bf9ddba0075f3af36041a1844dd207881047f/python_crontab-3.2.0.tar.gz", hash = "sha256:40067d1dd39ade3460b2ad8557c7651514cd3851deffff61c5c60e1227c5c36b", size = 57001 } +sdist = { url = "https://files.pythonhosted.org/packages/99/7f/c54fb7e70b59844526aa4ae321e927a167678660ab51dda979955eafb89a/python_crontab-3.3.0.tar.gz", hash = "sha256:007c8aee68dddf3e04ec4dce0fac124b93bd68be7470fc95d2a9617a15de291b", size = 57626, upload-time = "2025-07-13T20:05:35.535Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/91/832fb3b3a1f62bd2ab4924f6be0c7736c9bc4f84d3b153b74efcf6d4e4a1/python_crontab-3.2.0-py3-none-any.whl", hash = "sha256:82cb9b6a312d41ff66fd3caf3eed7115c28c195bfb50711bc2b4b9592feb9fe5", size = 27351 }, + { url = "https://files.pythonhosted.org/packages/47/42/bb4afa5b088f64092036221843fc989b7db9d9d302494c1f8b024ee78a46/python_crontab-3.3.0-py3-none-any.whl", hash = "sha256:739a778b1a771379b75654e53fd4df58e5c63a9279a63b5dfe44c0fcc3ee7884", size = 27533, upload-time = "2025-07-13T20:05:34.266Z" }, ] [[package]] @@ -2592,38 +1848,38 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "six", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] [[package]] name = "python-dotenv" -version = "1.0.1" +version = "1.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 } +sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 }, + { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" }, ] [[package]] name = "python-fsutil" -version = "0.14.1" +version = "0.15.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/de/17/e7426ac2d9bad932bd6f893781c66c042660d92bec57adb50f36dc7380d5/python-fsutil-0.14.1.tar.gz", hash = "sha256:8fb204fa8059f37bdeee8a1dc0fff010170202ea47c4225ee71bb3c26f3997be", size = 26723 } +sdist = { url = "https://files.pythonhosted.org/packages/f9/4a/494de3f8b079f077d687f7b3e32b963f7613eaae2d7b5c1be34d7eafd19a/python_fsutil-0.15.0.tar.gz", hash = "sha256:b51d8ab7ee218314480ea251fff7fef513be4fbccfe72a5af4ff2954f8a4a2c4", size = 29669, upload-time = "2025-02-06T17:47:55.769Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4f/e6/c8a2cdf34316bb96a7601ed47778818da266d4917bd9575d3a9ba46aedb7/python_fsutil-0.14.1-py3-none-any.whl", hash = "sha256:0d45e623f0f4403f674bdd8ae7aa7d24a4b3132ea45c65416bd2865e6b20b035", size = 16079 }, + { url = "https://files.pythonhosted.org/packages/33/de/fc2c3fa9d1f29c017c8eba2448efe86495b762111cf613a4c6d860158970/python_fsutil-0.15.0-py3-none-any.whl", hash = "sha256:8ae31def522916e35caf67723b8526fe6e5fcc1e160ea2dc23c845567708ca6e", size = 20915, upload-time = "2025-02-06T17:47:53.658Z" }, ] [[package]] name = "python-ldap" -version = "3.4.4" +version = "3.4.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyasn1", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pyasn1-modules", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fd/8b/1eeb4025dc1d3ac2f16678f38dec9ebdde6271c74955b72db5ce7a4dbfbd/python-ldap-3.4.4.tar.gz", hash = "sha256:7edb0accec4e037797705f3a05cbf36a9fde50d08c8f67f2aef99a2628fab828", size = 377889 } +sdist = { url = "https://files.pythonhosted.org/packages/0c/88/8d2797decc42e1c1cdd926df4f005e938b0643d0d1219c08c2b5ee8ae0c0/python_ldap-3.4.5.tar.gz", hash = "sha256:b2f6ef1c37fe2c6a5a85212efe71311ee21847766a7d45fcb711f3b270a5f79a", size = 388482, upload-time = "2025-10-10T20:00:39.06Z" } [[package]] name = "python-slugify" @@ -2632,72 +1888,58 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "text-unidecode", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/c7/5e1547c44e31da50a460df93af11a535ace568ef89d7a811069ead340c4a/python-slugify-8.0.4.tar.gz", hash = "sha256:59202371d1d05b54a9e7720c5e038f928f45daaffe41dd10822f3907b937c856", size = 10921 } +sdist = { url = "https://files.pythonhosted.org/packages/87/c7/5e1547c44e31da50a460df93af11a535ace568ef89d7a811069ead340c4a/python-slugify-8.0.4.tar.gz", hash = "sha256:59202371d1d05b54a9e7720c5e038f928f45daaffe41dd10822f3907b937c856", size = 10921, upload-time = "2024-02-08T18:32:45.488Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl", hash = "sha256:276540b79961052b66b7d116620b36518847f52d5fd9e3a70164fc8c50faa6b8", size = 10051 }, + { url = "https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl", hash = "sha256:276540b79961052b66b7d116620b36518847f52d5fd9e3a70164fc8c50faa6b8", size = 10051, upload-time = "2024-02-08T18:32:43.911Z" }, ] [[package]] name = "python-statemachine" version = "2.5.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/45/91/4f05f3931d1e9b1df71b17dc08c43feddf2bed7dbf13f95323df2cc8e340/python_statemachine-2.5.0.tar.gz", hash = "sha256:ae88cd22e47930b92b983a2176e61d811e571b69897be2568ec812c2885fb93a", size = 403718 } +sdist = { url = "https://files.pythonhosted.org/packages/45/91/4f05f3931d1e9b1df71b17dc08c43feddf2bed7dbf13f95323df2cc8e340/python_statemachine-2.5.0.tar.gz", hash = "sha256:ae88cd22e47930b92b983a2176e61d811e571b69897be2568ec812c2885fb93a", size = 403718, upload-time = "2024-12-03T17:58:49.833Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/2d/1c95ebe84df60d630f8e855d1df2c66368805444ac167e9b50f29eabe917/python_statemachine-2.5.0-py3-none-any.whl", hash = "sha256:0ed53846802c17037fcb2a92323f4bc0c833290fa9d17a3587c50886c1541e62", size = 50415 }, + { url = "https://files.pythonhosted.org/packages/bf/2d/1c95ebe84df60d630f8e855d1df2c66368805444ac167e9b50f29eabe917/python_statemachine-2.5.0-py3-none-any.whl", hash = "sha256:0ed53846802c17037fcb2a92323f4bc0c833290fa9d17a3587c50886c1541e62", size = 50415, upload-time = "2024-12-03T17:58:47.375Z" }, ] [[package]] name = "python-stdnum" -version = "1.20" +version = "2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/40/3f/dd322d9408e1850a8f0faab8e2a4bf2a55c0b722a72f7579362177dfad72/python-stdnum-1.20.tar.gz", hash = "sha256:ad2a2cf2eb025de408210235f36b4ae31252de3186240ccaa8126e117cb82690", size = 1191978 } +sdist = { url = "https://files.pythonhosted.org/packages/83/60/fd8299c7d8990a7d802286ac604862387bcac3df08be7cb1c932c33ef7da/python_stdnum-2.1.tar.gz", hash = "sha256:6b01645969eb3dfd55061a0114d593753cd9e653cea9083198b7eea12644397a", size = 1238596, upload-time = "2025-05-17T13:18:43.506Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d6/0f/8639d60f6d7c169836694aa81504c4ee9a95dfb73ccdb16be66df4785f52/python_stdnum-1.20-py2.py3-none-any.whl", hash = "sha256:111008e10391d54fb2afad2a10df70d5cb0c6c0a7ec82fec6f022cb8712961d3", size = 1059803 }, + { url = "https://files.pythonhosted.org/packages/67/04/730f619b5b8470adf0e029ee2f0a060689145ea64dec001c8bac3c3959e2/python_stdnum-2.1-py3-none-any.whl", hash = "sha256:25eabcf5f307dd4150fd8f1c03f4512a6caeb84c9f09be1448711f5803373c58", size = 1120175, upload-time = "2025-05-17T13:18:41.193Z" }, ] [[package]] name = "pytz" -version = "2024.2" +version = "2025.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 }, + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, ] [[package]] name = "pyyaml" -version = "6.0.2" +version = "6.0.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, - { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, - { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, - { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, - { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, - { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, - { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, - { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, - { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, - { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, - { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, - { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, - { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, - { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, - { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, - { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, - { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, - { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, - { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, - { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, - { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, - { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, - { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, - { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, - { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, - { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, - { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, - { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, ] [[package]] @@ -2709,75 +1951,44 @@ dependencies = [ { name = "docutils", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1c/00/3dd2bdc4184b0ce754b5b446325abf45c2e0a347e022292ddc44670f628c/recommonmark-0.7.1.tar.gz", hash = "sha256:bdb4db649f2222dcd8d2d844f0006b958d627f732415d399791ee436a3686d67", size = 34444 } +sdist = { url = "https://files.pythonhosted.org/packages/1c/00/3dd2bdc4184b0ce754b5b446325abf45c2e0a347e022292ddc44670f628c/recommonmark-0.7.1.tar.gz", hash = "sha256:bdb4db649f2222dcd8d2d844f0006b958d627f732415d399791ee436a3686d67", size = 34444, upload-time = "2020-12-17T19:24:56.523Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/77/ed589c75db5d02a77a1d5d2d9abc63f29676467d396c64277f98b50b79c2/recommonmark-0.7.1-py2.py3-none-any.whl", hash = "sha256:1b1db69af0231efce3fa21b94ff627ea33dee7079a01dd0a7f8482c3da148b3f", size = 10214 }, + { url = "https://files.pythonhosted.org/packages/c6/77/ed589c75db5d02a77a1d5d2d9abc63f29676467d396c64277f98b50b79c2/recommonmark-0.7.1-py2.py3-none-any.whl", hash = "sha256:1b1db69af0231efce3fa21b94ff627ea33dee7079a01dd0a7f8482c3da148b3f", size = 10214, upload-time = "2020-12-17T19:24:55.137Z" }, ] [[package]] name = "regex" -version = "2024.11.6" +version = "2025.11.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8e/5f/bd69653fbfb76cf8604468d3b4ec4c403197144c7bfe0e6a5fc9e02a07cb/regex-2024.11.6.tar.gz", hash = "sha256:7ab159b063c52a0333c884e4679f8d7a85112ee3078fe3d9004b2dd875585519", size = 399494 } +sdist = { url = "https://files.pythonhosted.org/packages/cc/a9/546676f25e573a4cf00fe8e119b78a37b6a8fe2dc95cda877b30889c9c45/regex-2025.11.3.tar.gz", hash = "sha256:1fedc720f9bb2494ce31a58a1631f9c82df6a09b49c19517ea5cc280b4541e01", size = 414669, upload-time = "2025-11-03T21:34:22.089Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/3c/4651f6b130c6842a8f3df82461a8950f923925db8b6961063e82744bddcc/regex-2024.11.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff590880083d60acc0433f9c3f713c51f7ac6ebb9adf889c79a261ecf541aa91", size = 482674 }, - { url = "https://files.pythonhosted.org/packages/15/51/9f35d12da8434b489c7b7bffc205c474a0a9432a889457026e9bc06a297a/regex-2024.11.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:658f90550f38270639e83ce492f27d2c8d2cd63805c65a13a14d36ca126753f0", size = 287684 }, - { url = "https://files.pythonhosted.org/packages/bd/18/b731f5510d1b8fb63c6b6d3484bfa9a59b84cc578ac8b5172970e05ae07c/regex-2024.11.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:164d8b7b3b4bcb2068b97428060b2a53be050085ef94eca7f240e7947f1b080e", size = 284589 }, - { url = "https://files.pythonhosted.org/packages/78/a2/6dd36e16341ab95e4c6073426561b9bfdeb1a9c9b63ab1b579c2e96cb105/regex-2024.11.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3660c82f209655a06b587d55e723f0b813d3a7db2e32e5e7dc64ac2a9e86fde", size = 782511 }, - { url = "https://files.pythonhosted.org/packages/1b/2b/323e72d5d2fd8de0d9baa443e1ed70363ed7e7b2fb526f5950c5cb99c364/regex-2024.11.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d22326fcdef5e08c154280b71163ced384b428343ae16a5ab2b3354aed12436e", size = 821149 }, - { url = "https://files.pythonhosted.org/packages/90/30/63373b9ea468fbef8a907fd273e5c329b8c9535fee36fc8dba5fecac475d/regex-2024.11.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1ac758ef6aebfc8943560194e9fd0fa18bcb34d89fd8bd2af18183afd8da3a2", size = 809707 }, - { url = "https://files.pythonhosted.org/packages/f2/98/26d3830875b53071f1f0ae6d547f1d98e964dd29ad35cbf94439120bb67a/regex-2024.11.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:997d6a487ff00807ba810e0f8332c18b4eb8d29463cfb7c820dc4b6e7562d0cf", size = 781702 }, - { url = "https://files.pythonhosted.org/packages/87/55/eb2a068334274db86208ab9d5599ffa63631b9f0f67ed70ea7c82a69bbc8/regex-2024.11.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02a02d2bb04fec86ad61f3ea7f49c015a0681bf76abb9857f945d26159d2968c", size = 771976 }, - { url = "https://files.pythonhosted.org/packages/74/c0/be707bcfe98254d8f9d2cff55d216e946f4ea48ad2fd8cf1428f8c5332ba/regex-2024.11.6-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f02f93b92358ee3f78660e43b4b0091229260c5d5c408d17d60bf26b6c900e86", size = 697397 }, - { url = "https://files.pythonhosted.org/packages/49/dc/bb45572ceb49e0f6509f7596e4ba7031f6819ecb26bc7610979af5a77f45/regex-2024.11.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:06eb1be98df10e81ebaded73fcd51989dcf534e3c753466e4b60c4697a003b67", size = 768726 }, - { url = "https://files.pythonhosted.org/packages/5a/db/f43fd75dc4c0c2d96d0881967897926942e935d700863666f3c844a72ce6/regex-2024.11.6-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:040df6fe1a5504eb0f04f048e6d09cd7c7110fef851d7c567a6b6e09942feb7d", size = 775098 }, - { url = "https://files.pythonhosted.org/packages/99/d7/f94154db29ab5a89d69ff893159b19ada89e76b915c1293e98603d39838c/regex-2024.11.6-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabbfc59f2c6edba2a6622c647b716e34e8e3867e0ab975412c5c2f79b82da2", size = 839325 }, - { url = "https://files.pythonhosted.org/packages/f7/17/3cbfab1f23356fbbf07708220ab438a7efa1e0f34195bf857433f79f1788/regex-2024.11.6-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8447d2d39b5abe381419319f942de20b7ecd60ce86f16a23b0698f22e1b70008", size = 843277 }, - { url = "https://files.pythonhosted.org/packages/7e/f2/48b393b51900456155de3ad001900f94298965e1cad1c772b87f9cfea011/regex-2024.11.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:da8f5fc57d1933de22a9e23eec290a0d8a5927a5370d24bda9a6abe50683fe62", size = 773197 }, - { url = "https://files.pythonhosted.org/packages/58/58/7e4d9493a66c88a7da6d205768119f51af0f684fe7be7bac8328e217a52c/regex-2024.11.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5478c6962ad548b54a591778e93cd7c456a7a29f8eca9c49e4f9a806dcc5d638", size = 482669 }, - { url = "https://files.pythonhosted.org/packages/34/4c/8f8e631fcdc2ff978609eaeef1d6994bf2f028b59d9ac67640ed051f1218/regex-2024.11.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2c89a8cc122b25ce6945f0423dc1352cb9593c68abd19223eebbd4e56612c5b7", size = 287684 }, - { url = "https://files.pythonhosted.org/packages/c5/1b/f0e4d13e6adf866ce9b069e191f303a30ab1277e037037a365c3aad5cc9c/regex-2024.11.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:94d87b689cdd831934fa3ce16cc15cd65748e6d689f5d2b8f4f4df2065c9fa20", size = 284589 }, - { url = "https://files.pythonhosted.org/packages/25/4d/ab21047f446693887f25510887e6820b93f791992994f6498b0318904d4a/regex-2024.11.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1062b39a0a2b75a9c694f7a08e7183a80c63c0d62b301418ffd9c35f55aaa114", size = 792121 }, - { url = "https://files.pythonhosted.org/packages/45/ee/c867e15cd894985cb32b731d89576c41a4642a57850c162490ea34b78c3b/regex-2024.11.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:167ed4852351d8a750da48712c3930b031f6efdaa0f22fa1933716bfcd6bf4a3", size = 831275 }, - { url = "https://files.pythonhosted.org/packages/b3/12/b0f480726cf1c60f6536fa5e1c95275a77624f3ac8fdccf79e6727499e28/regex-2024.11.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d548dafee61f06ebdb584080621f3e0c23fff312f0de1afc776e2a2ba99a74f", size = 818257 }, - { url = "https://files.pythonhosted.org/packages/bf/ce/0d0e61429f603bac433910d99ef1a02ce45a8967ffbe3cbee48599e62d88/regex-2024.11.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a19f302cd1ce5dd01a9099aaa19cae6173306d1302a43b627f62e21cf18ac0", size = 792727 }, - { url = "https://files.pythonhosted.org/packages/e4/c1/243c83c53d4a419c1556f43777ccb552bccdf79d08fda3980e4e77dd9137/regex-2024.11.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bec9931dfb61ddd8ef2ebc05646293812cb6b16b60cf7c9511a832b6f1854b55", size = 780667 }, - { url = "https://files.pythonhosted.org/packages/c5/f4/75eb0dd4ce4b37f04928987f1d22547ddaf6c4bae697623c1b05da67a8aa/regex-2024.11.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9714398225f299aa85267fd222f7142fcb5c769e73d7733344efc46f2ef5cf89", size = 776963 }, - { url = "https://files.pythonhosted.org/packages/16/5d/95c568574e630e141a69ff8a254c2f188b4398e813c40d49228c9bbd9875/regex-2024.11.6-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:202eb32e89f60fc147a41e55cb086db2a3f8cb82f9a9a88440dcfc5d37faae8d", size = 784700 }, - { url = "https://files.pythonhosted.org/packages/8e/b5/f8495c7917f15cc6fee1e7f395e324ec3e00ab3c665a7dc9d27562fd5290/regex-2024.11.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4181b814e56078e9b00427ca358ec44333765f5ca1b45597ec7446d3a1ef6e34", size = 848592 }, - { url = "https://files.pythonhosted.org/packages/1c/80/6dd7118e8cb212c3c60b191b932dc57db93fb2e36fb9e0e92f72a5909af9/regex-2024.11.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:068376da5a7e4da51968ce4c122a7cd31afaaec4fccc7856c92f63876e57b51d", size = 852929 }, - { url = "https://files.pythonhosted.org/packages/11/9b/5a05d2040297d2d254baf95eeeb6df83554e5e1df03bc1a6687fc4ba1f66/regex-2024.11.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ac10f2c4184420d881a3475fb2c6f4d95d53a8d50209a2500723d831036f7c45", size = 781213 }, - { url = "https://files.pythonhosted.org/packages/ba/30/9a87ce8336b172cc232a0db89a3af97929d06c11ceaa19d97d84fa90a8f8/regex-2024.11.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:52fb28f528778f184f870b7cf8f225f5eef0a8f6e3778529bdd40c7b3920796a", size = 483781 }, - { url = "https://files.pythonhosted.org/packages/01/e8/00008ad4ff4be8b1844786ba6636035f7ef926db5686e4c0f98093612add/regex-2024.11.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdd6028445d2460f33136c55eeb1f601ab06d74cb3347132e1c24250187500d9", size = 288455 }, - { url = "https://files.pythonhosted.org/packages/60/85/cebcc0aff603ea0a201667b203f13ba75d9fc8668fab917ac5b2de3967bc/regex-2024.11.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805e6b60c54bf766b251e94526ebad60b7de0c70f70a4e6210ee2891acb70bf2", size = 284759 }, - { url = "https://files.pythonhosted.org/packages/94/2b/701a4b0585cb05472a4da28ee28fdfe155f3638f5e1ec92306d924e5faf0/regex-2024.11.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b85c2530be953a890eaffde05485238f07029600e8f098cdf1848d414a8b45e4", size = 794976 }, - { url = "https://files.pythonhosted.org/packages/4b/bf/fa87e563bf5fee75db8915f7352e1887b1249126a1be4813837f5dbec965/regex-2024.11.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb26437975da7dc36b7efad18aa9dd4ea569d2357ae6b783bf1118dabd9ea577", size = 833077 }, - { url = "https://files.pythonhosted.org/packages/a1/56/7295e6bad94b047f4d0834e4779491b81216583c00c288252ef625c01d23/regex-2024.11.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abfa5080c374a76a251ba60683242bc17eeb2c9818d0d30117b4486be10c59d3", size = 823160 }, - { url = "https://files.pythonhosted.org/packages/fb/13/e3b075031a738c9598c51cfbc4c7879e26729c53aa9cca59211c44235314/regex-2024.11.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b7fa6606c2881c1db9479b0eaa11ed5dfa11c8d60a474ff0e095099f39d98e", size = 796896 }, - { url = "https://files.pythonhosted.org/packages/24/56/0b3f1b66d592be6efec23a795b37732682520b47c53da5a32c33ed7d84e3/regex-2024.11.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c32f75920cf99fe6b6c539c399a4a128452eaf1af27f39bce8909c9a3fd8cbe", size = 783997 }, - { url = "https://files.pythonhosted.org/packages/f9/a1/eb378dada8b91c0e4c5f08ffb56f25fcae47bf52ad18f9b2f33b83e6d498/regex-2024.11.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:982e6d21414e78e1f51cf595d7f321dcd14de1f2881c5dc6a6e23bbbbd68435e", size = 781725 }, - { url = "https://files.pythonhosted.org/packages/83/f2/033e7dec0cfd6dda93390089864732a3409246ffe8b042e9554afa9bff4e/regex-2024.11.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a7c2155f790e2fb448faed6dd241386719802296ec588a8b9051c1f5c481bc29", size = 789481 }, - { url = "https://files.pythonhosted.org/packages/83/23/15d4552ea28990a74e7696780c438aadd73a20318c47e527b47a4a5a596d/regex-2024.11.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149f5008d286636e48cd0b1dd65018548944e495b0265b45e1bffecce1ef7f39", size = 852896 }, - { url = "https://files.pythonhosted.org/packages/e3/39/ed4416bc90deedbfdada2568b2cb0bc1fdb98efe11f5378d9892b2a88f8f/regex-2024.11.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e5364a4502efca094731680e80009632ad6624084aff9a23ce8c8c6820de3e51", size = 860138 }, - { url = "https://files.pythonhosted.org/packages/93/2d/dd56bb76bd8e95bbce684326302f287455b56242a4f9c61f1bc76e28360e/regex-2024.11.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0a86e7eeca091c09e021db8eb72d54751e527fa47b8d5787caf96d9831bd02ad", size = 787692 }, - { url = "https://files.pythonhosted.org/packages/90/73/bcb0e36614601016552fa9344544a3a2ae1809dc1401b100eab02e772e1f/regex-2024.11.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a6ba92c0bcdf96cbf43a12c717eae4bc98325ca3730f6b130ffa2e3c3c723d84", size = 483525 }, - { url = "https://files.pythonhosted.org/packages/0f/3f/f1a082a46b31e25291d830b369b6b0c5576a6f7fb89d3053a354c24b8a83/regex-2024.11.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:525eab0b789891ac3be914d36893bdf972d483fe66551f79d3e27146191a37d4", size = 288324 }, - { url = "https://files.pythonhosted.org/packages/09/c9/4e68181a4a652fb3ef5099e077faf4fd2a694ea6e0f806a7737aff9e758a/regex-2024.11.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:086a27a0b4ca227941700e0b31425e7a28ef1ae8e5e05a33826e17e47fbfdba0", size = 284617 }, - { url = "https://files.pythonhosted.org/packages/fc/fd/37868b75eaf63843165f1d2122ca6cb94bfc0271e4428cf58c0616786dce/regex-2024.11.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bde01f35767c4a7899b7eb6e823b125a64de314a8ee9791367c9a34d56af18d0", size = 795023 }, - { url = "https://files.pythonhosted.org/packages/c4/7c/d4cd9c528502a3dedb5c13c146e7a7a539a3853dc20209c8e75d9ba9d1b2/regex-2024.11.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b583904576650166b3d920d2bcce13971f6f9e9a396c673187f49811b2769dc7", size = 833072 }, - { url = "https://files.pythonhosted.org/packages/4f/db/46f563a08f969159c5a0f0e722260568425363bea43bb7ae370becb66a67/regex-2024.11.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c4de13f06a0d54fa0d5ab1b7138bfa0d883220965a29616e3ea61b35d5f5fc7", size = 823130 }, - { url = "https://files.pythonhosted.org/packages/db/60/1eeca2074f5b87df394fccaa432ae3fc06c9c9bfa97c5051aed70e6e00c2/regex-2024.11.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cde6e9f2580eb1665965ce9bf17ff4952f34f5b126beb509fee8f4e994f143c", size = 796857 }, - { url = "https://files.pythonhosted.org/packages/10/db/ac718a08fcee981554d2f7bb8402f1faa7e868c1345c16ab1ebec54b0d7b/regex-2024.11.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d7f453dca13f40a02b79636a339c5b62b670141e63efd511d3f8f73fba162b3", size = 784006 }, - { url = "https://files.pythonhosted.org/packages/c2/41/7da3fe70216cea93144bf12da2b87367590bcf07db97604edeea55dac9ad/regex-2024.11.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59dfe1ed21aea057a65c6b586afd2a945de04fc7db3de0a6e3ed5397ad491b07", size = 781650 }, - { url = "https://files.pythonhosted.org/packages/a7/d5/880921ee4eec393a4752e6ab9f0fe28009435417c3102fc413f3fe81c4e5/regex-2024.11.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b97c1e0bd37c5cd7902e65f410779d39eeda155800b65fc4d04cc432efa9bc6e", size = 789545 }, - { url = "https://files.pythonhosted.org/packages/dc/96/53770115e507081122beca8899ab7f5ae28ae790bfcc82b5e38976df6a77/regex-2024.11.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d1e379028e0fc2ae3654bac3cbbef81bf3fd571272a42d56c24007979bafb6", size = 853045 }, - { url = "https://files.pythonhosted.org/packages/31/d3/1372add5251cc2d44b451bd94f43b2ec78e15a6e82bff6a290ef9fd8f00a/regex-2024.11.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:13291b39131e2d002a7940fb176e120bec5145f3aeb7621be6534e46251912c4", size = 860182 }, - { url = "https://files.pythonhosted.org/packages/ed/e3/c446a64984ea9f69982ba1a69d4658d5014bc7a0ea468a07e1a1265db6e2/regex-2024.11.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f51f88c126370dcec4908576c5a627220da6c09d0bff31cfa89f2523843316d", size = 787733 }, + { url = "https://files.pythonhosted.org/packages/31/e9/f6e13de7e0983837f7b6d238ad9458800a874bf37c264f7923e63409944c/regex-2025.11.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9697a52e57576c83139d7c6f213d64485d3df5bf84807c35fa409e6c970801c6", size = 489089, upload-time = "2025-11-03T21:32:50.027Z" }, + { url = "https://files.pythonhosted.org/packages/a3/5c/261f4a262f1fa65141c1b74b255988bd2fa020cc599e53b080667d591cfc/regex-2025.11.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e18bc3f73bd41243c9b38a6d9f2366cd0e0137a9aebe2d8ff76c5b67d4c0a3f4", size = 291059, upload-time = "2025-11-03T21:32:51.682Z" }, + { url = "https://files.pythonhosted.org/packages/8e/57/f14eeb7f072b0e9a5a090d1712741fd8f214ec193dba773cf5410108bb7d/regex-2025.11.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:61a08bcb0ec14ff4e0ed2044aad948d0659604f824cbd50b55e30b0ec6f09c73", size = 288900, upload-time = "2025-11-03T21:32:53.569Z" }, + { url = "https://files.pythonhosted.org/packages/3c/6b/1d650c45e99a9b327586739d926a1cd4e94666b1bd4af90428b36af66dc7/regex-2025.11.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9c30003b9347c24bcc210958c5d167b9e4f9be786cb380a7d32f14f9b84674f", size = 799010, upload-time = "2025-11-03T21:32:55.222Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/d66dcbc6b628ce4e3f7f0cbbb84603aa2fc0ffc878babc857726b8aab2e9/regex-2025.11.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4e1e592789704459900728d88d41a46fe3969b82ab62945560a31732ffc19a6d", size = 864893, upload-time = "2025-11-03T21:32:57.239Z" }, + { url = "https://files.pythonhosted.org/packages/bf/2d/f238229f1caba7ac87a6c4153d79947fb0261415827ae0f77c304260c7d3/regex-2025.11.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6538241f45eb5a25aa575dbba1069ad786f68a4f2773a29a2bd3dd1f9de787be", size = 911522, upload-time = "2025-11-03T21:32:59.274Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3d/22a4eaba214a917c80e04f6025d26143690f0419511e0116508e24b11c9b/regex-2025.11.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce22519c989bb72a7e6b36a199384c53db7722fe669ba891da75907fe3587db", size = 803272, upload-time = "2025-11-03T21:33:01.393Z" }, + { url = "https://files.pythonhosted.org/packages/84/b1/03188f634a409353a84b5ef49754b97dbcc0c0f6fd6c8ede505a8960a0a4/regex-2025.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:66d559b21d3640203ab9075797a55165d79017520685fb407b9234d72ab63c62", size = 787958, upload-time = "2025-11-03T21:33:03.379Z" }, + { url = "https://files.pythonhosted.org/packages/99/6a/27d072f7fbf6fadd59c64d210305e1ff865cc3b78b526fd147db768c553b/regex-2025.11.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:669dcfb2e38f9e8c69507bace46f4889e3abbfd9b0c29719202883c0a603598f", size = 859289, upload-time = "2025-11-03T21:33:05.374Z" }, + { url = "https://files.pythonhosted.org/packages/9a/70/1b3878f648e0b6abe023172dacb02157e685564853cc363d9961bcccde4e/regex-2025.11.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:32f74f35ff0f25a5021373ac61442edcb150731fbaa28286bbc8bb1582c89d02", size = 850026, upload-time = "2025-11-03T21:33:07.131Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d5/68e25559b526b8baab8e66839304ede68ff6727237a47727d240006bd0ff/regex-2025.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e6c7a21dffba883234baefe91bc3388e629779582038f75d2a5be918e250f0ed", size = 789499, upload-time = "2025-11-03T21:33:09.141Z" }, + { url = "https://files.pythonhosted.org/packages/c3/06/49b198550ee0f5e4184271cee87ba4dfd9692c91ec55289e6282f0f86ccf/regex-2025.11.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ba0d8a5d7f04f73ee7d01d974d47c5834f8a1b0224390e4fe7c12a3a92a78ecc", size = 491985, upload-time = "2025-11-03T21:33:16.555Z" }, + { url = "https://files.pythonhosted.org/packages/ce/bf/abdafade008f0b1c9da10d934034cb670432d6cf6cbe38bbb53a1cfd6cf8/regex-2025.11.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:442d86cf1cfe4faabf97db7d901ef58347efd004934da045c745e7b5bd57ac49", size = 292669, upload-time = "2025-11-03T21:33:18.32Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ef/0c357bb8edbd2ad8e273fcb9e1761bc37b8acbc6e1be050bebd6475f19c1/regex-2025.11.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fd0a5e563c756de210bb964789b5abe4f114dacae9104a47e1a649b910361536", size = 291030, upload-time = "2025-11-03T21:33:20.048Z" }, + { url = "https://files.pythonhosted.org/packages/79/06/edbb67257596649b8fb088d6aeacbcb248ac195714b18a65e018bf4c0b50/regex-2025.11.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3490bcbb985a1ae97b2ce9ad1c0f06a852d5b19dde9b07bdf25bf224248c95", size = 807674, upload-time = "2025-11-03T21:33:21.797Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d9/ad4deccfce0ea336296bd087f1a191543bb99ee1c53093dcd4c64d951d00/regex-2025.11.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3809988f0a8b8c9dcc0f92478d6501fac7200b9ec56aecf0ec21f4a2ec4b6009", size = 873451, upload-time = "2025-11-03T21:33:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/13/75/a55a4724c56ef13e3e04acaab29df26582f6978c000ac9cd6810ad1f341f/regex-2025.11.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f4ff94e58e84aedb9c9fce66d4ef9f27a190285b451420f297c9a09f2b9abee9", size = 914980, upload-time = "2025-11-03T21:33:25.999Z" }, + { url = "https://files.pythonhosted.org/packages/67/1e/a1657ee15bd9116f70d4a530c736983eed997b361e20ecd8f5ca3759d5c5/regex-2025.11.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eb542fd347ce61e1321b0a6b945d5701528dca0cd9759c2e3bb8bd57e47964d", size = 812852, upload-time = "2025-11-03T21:33:27.852Z" }, + { url = "https://files.pythonhosted.org/packages/b8/6f/f7516dde5506a588a561d296b2d0044839de06035bb486b326065b4c101e/regex-2025.11.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6c2d5919075a1f2e413c00b056ea0c2f065b3f5fe83c3d07d325ab92dce51d6", size = 795566, upload-time = "2025-11-03T21:33:32.364Z" }, + { url = "https://files.pythonhosted.org/packages/d9/dd/3d10b9e170cc16fb34cb2cef91513cf3df65f440b3366030631b2984a264/regex-2025.11.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3f8bf11a4827cc7ce5a53d4ef6cddd5ad25595d3c1435ef08f76825851343154", size = 868463, upload-time = "2025-11-03T21:33:34.459Z" }, + { url = "https://files.pythonhosted.org/packages/f5/8e/935e6beff1695aa9085ff83195daccd72acc82c81793df480f34569330de/regex-2025.11.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:22c12d837298651e5550ac1d964e4ff57c3f56965fc1812c90c9fb2028eaf267", size = 854694, upload-time = "2025-11-03T21:33:36.793Z" }, + { url = "https://files.pythonhosted.org/packages/92/12/10650181a040978b2f5720a6a74d44f841371a3d984c2083fc1752e4acf6/regex-2025.11.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ba394a3dda9ad41c7c780f60f6e4a70988741415ae96f6d1bf6c239cf01379", size = 799691, upload-time = "2025-11-03T21:33:39.079Z" }, ] [[package]] name = "requests" -version = "2.32.3" +version = "2.32.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "certifi", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2785,9 +1996,9 @@ dependencies = [ { name = "idna", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "urllib3", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, ] [[package]] @@ -2798,59 +2009,79 @@ dependencies = [ { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sqlparse", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e9/10/35d214c4eaa479251ebb6f774842e476cd4162ca939e72bb1d943131fb2c/requests_tracker-0.3.3.tar.gz", hash = "sha256:eb288d69ebcae49149b41d603960d101d7eb892627e3455a456fa1f9441d2a49", size = 49168 } +sdist = { url = "https://files.pythonhosted.org/packages/e9/10/35d214c4eaa479251ebb6f774842e476cd4162ca939e72bb1d943131fb2c/requests_tracker-0.3.3.tar.gz", hash = "sha256:eb288d69ebcae49149b41d603960d101d7eb892627e3455a456fa1f9441d2a49", size = 49168, upload-time = "2023-11-04T01:24:11.992Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/16/f5/d2fd9443c1839edf0c17216e9ab03201c16468e82e2968504fc738cd6917/requests_tracker-0.3.3-py3-none-any.whl", hash = "sha256:31d8924470ceea34be51743142c5248f1bf625d2ff95d1f0dccc2cfe14ecda0b", size = 58078 }, + { url = "https://files.pythonhosted.org/packages/16/f5/d2fd9443c1839edf0c17216e9ab03201c16468e82e2968504fc738cd6917/requests_tracker-0.3.3-py3-none-any.whl", hash = "sha256:31d8924470ceea34be51743142c5248f1bf625d2ff95d1f0dccc2cfe14ecda0b", size = 58078, upload-time = "2023-11-04T01:24:09.924Z" }, ] [[package]] name = "rich" -version = "13.9.4" +version = "14.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markdown-it-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pygments", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 } +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, ] [[package]] name = "rich-click" -version = "1.8.5" +version = "1.9.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9a/31/103501e85e885e3e202c087fa612cfe450693210372766552ce1ab5b57b9/rich_click-1.8.5.tar.gz", hash = "sha256:a3eebe81da1c9da3c32f3810017c79bd687ff1b3fa35bfc9d8a3338797f1d1a1", size = 38229 } +sdist = { url = "https://files.pythonhosted.org/packages/6b/d1/b60ca6a8745e76800b50c7ee246fd73f08a3be5d8e0b551fc93c19fa1203/rich_click-1.9.5.tar.gz", hash = "sha256:48120531493f1533828da80e13e839d471979ec8d7d0ca7b35f86a1379cc74b6", size = 73927, upload-time = "2025-12-21T14:49:44.167Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/aa/0b/e2de98c538c0ee9336211d260f88b7e69affab44969750aaca0b48a697c8/rich_click-1.8.5-py3-none-any.whl", hash = "sha256:0fab7bb5b66c15da17c210b4104277cd45f3653a7322e0098820a169880baee0", size = 35081 }, + { url = "https://files.pythonhosted.org/packages/25/0a/d865895e1e5d88a60baee0fc3703eb111c502ee10c8c107516bc7623abf8/rich_click-1.9.5-py3-none-any.whl", hash = "sha256:9b195721a773b1acf0e16ff9ec68cef1e7d237e53471e6e3f7ade462f86c403a", size = 70580, upload-time = "2025-12-21T14:49:42.905Z" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, +] + +[[package]] +name = "roman-numerals-py" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "roman-numerals", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/b5/de96fca640f4f656eb79bbee0e79aeec52e3e0e359f8a3e6a0d366378b64/roman_numerals_py-4.1.0.tar.gz", hash = "sha256:f5d7b2b4ca52dd855ef7ab8eb3590f428c0b1ea480736ce32b01fef2a5f8daf9", size = 4274, upload-time = "2025-12-17T18:25:41.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/2c/daca29684cbe9fd4bc711f8246da3c10adca1ccc4d24436b17572eb2590e/roman_numerals_py-4.1.0-py3-none-any.whl", hash = "sha256:553114c1167141c1283a51743759723ecd05604a1b6b507225e91dc1a6df0780", size = 4547, upload-time = "2025-12-17T18:25:40.136Z" }, ] [[package]] name = "ruff" -version = "0.8.3" +version = "0.14.10" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bf/5e/683c7ef7a696923223e7d95ca06755d6e2acbc5fd8382b2912a28008137c/ruff-0.8.3.tar.gz", hash = "sha256:5e7558304353b84279042fc584a4f4cb8a07ae79b2bf3da1a7551d960b5626d3", size = 3378522 } +sdist = { url = "https://files.pythonhosted.org/packages/57/08/52232a877978dd8f9cf2aeddce3e611b40a63287dfca29b6b8da791f5e8d/ruff-0.14.10.tar.gz", hash = "sha256:9a2e830f075d1a42cd28420d7809ace390832a490ed0966fe373ba288e77aaf4", size = 5859763, upload-time = "2025-12-18T19:28:57.98Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f8/c4/bfdbb8b9c419ff3b52479af8581026eeaac3764946fdb463dec043441b7d/ruff-0.8.3-py3-none-linux_armv6l.whl", hash = "sha256:8d5d273ffffff0acd3db5bf626d4b131aa5a5ada1276126231c4174543ce20d6", size = 10535860 }, - { url = "https://files.pythonhosted.org/packages/ef/c5/0aabdc9314b4b6f051168ac45227e2aa8e1c6d82718a547455e40c9c9faa/ruff-0.8.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e4d66a21de39f15c9757d00c50c8cdd20ac84f55684ca56def7891a025d7e939", size = 10346327 }, - { url = "https://files.pythonhosted.org/packages/1a/78/4843a59e7e7b398d6019cf91ab06502fd95397b99b2b858798fbab9151f5/ruff-0.8.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c356e770811858bd20832af696ff6c7e884701115094f427b64b25093d6d932d", size = 9942585 }, - { url = "https://files.pythonhosted.org/packages/91/5a/642ed8f1ba23ffc2dd347697e01eef3c42fad6ac76603be4a8c3a9d6311e/ruff-0.8.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c0a60a825e3e177116c84009d5ebaa90cf40dfab56e1358d1df4e29a9a14b13", size = 10797597 }, - { url = "https://files.pythonhosted.org/packages/30/25/2e654bc7226da09a49730a1a2ea6e89f843b362db80b4b2a7a4f948ac986/ruff-0.8.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75fb782f4db39501210ac093c79c3de581d306624575eddd7e4e13747e61ba18", size = 10307244 }, - { url = "https://files.pythonhosted.org/packages/c0/2d/a224d56bcd4383583db53c2b8f410ebf1200866984aa6eb9b5a70f04e71f/ruff-0.8.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f26bc76a133ecb09a38b7868737eded6941b70a6d34ef53a4027e83913b6502", size = 11362439 }, - { url = "https://files.pythonhosted.org/packages/82/01/03e2857f9c371b8767d3e909f06a33bbdac880df17f17f93d6f6951c3381/ruff-0.8.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:01b14b2f72a37390c1b13477c1c02d53184f728be2f3ffc3ace5b44e9e87b90d", size = 12078538 }, - { url = "https://files.pythonhosted.org/packages/af/ae/ff7f97b355da16d748ceec50e1604a8215d3659b36b38025a922e0612e9b/ruff-0.8.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:53babd6e63e31f4e96ec95ea0d962298f9f0d9cc5990a1bbb023a6baf2503a82", size = 11616172 }, - { url = "https://files.pythonhosted.org/packages/6a/d0/6156d4d1e53ebd17747049afe801c5d7e3014d9b2f398b9236fe36ba4320/ruff-0.8.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1ae441ce4cf925b7f363d33cd6570c51435972d697e3e58928973994e56e1452", size = 12919886 }, - { url = "https://files.pythonhosted.org/packages/4e/84/affcb30bacb94f6036a128ad5de0e29f543d3f67ee42b490b17d68e44b8a/ruff-0.8.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7c65bc0cadce32255e93c57d57ecc2cca23149edd52714c0c5d6fa11ec328cd", size = 11212599 }, - { url = "https://files.pythonhosted.org/packages/60/b9/5694716bdefd8f73df7c0104334156c38fb0f77673d2966a5a1345bab94d/ruff-0.8.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5be450bb18f23f0edc5a4e5585c17a56ba88920d598f04a06bd9fd76d324cb20", size = 10784637 }, - { url = "https://files.pythonhosted.org/packages/24/7e/0e8f835103ac7da81c3663eedf79dec8359e9ae9a3b0d704bae50be59176/ruff-0.8.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8faeae3827eaa77f5721f09b9472a18c749139c891dbc17f45e72d8f2ca1f8fc", size = 10390591 }, - { url = "https://files.pythonhosted.org/packages/27/da/180ec771fc01c004045962ce017ca419a0281f4bfaf867ed0020f555b56e/ruff-0.8.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:db503486e1cf074b9808403991663e4277f5c664d3fe237ee0d994d1305bb060", size = 10894298 }, - { url = "https://files.pythonhosted.org/packages/6d/f8/29f241742ed3954eb2222314b02db29f531a15cab3238d1295e8657c5f18/ruff-0.8.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6567be9fb62fbd7a099209257fef4ad2c3153b60579818b31a23c886ed4147ea", size = 11275965 }, + { url = "https://files.pythonhosted.org/packages/60/01/933704d69f3f05ee16ef11406b78881733c186fe14b6a46b05cfcaf6d3b2/ruff-0.14.10-py3-none-linux_armv6l.whl", hash = "sha256:7a3ce585f2ade3e1f29ec1b92df13e3da262178df8c8bdf876f48fa0e8316c49", size = 13527080, upload-time = "2025-12-18T19:29:25.642Z" }, + { url = "https://files.pythonhosted.org/packages/df/58/a0349197a7dfa603ffb7f5b0470391efa79ddc327c1e29c4851e85b09cc5/ruff-0.14.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:674f9be9372907f7257c51f1d4fc902cb7cf014b9980152b802794317941f08f", size = 13797320, upload-time = "2025-12-18T19:29:02.571Z" }, + { url = "https://files.pythonhosted.org/packages/7b/82/36be59f00a6082e38c23536df4e71cdbc6af8d7c707eade97fcad5c98235/ruff-0.14.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d85713d522348837ef9df8efca33ccb8bd6fcfc86a2cde3ccb4bc9d28a18003d", size = 12918434, upload-time = "2025-12-18T19:28:51.202Z" }, + { url = "https://files.pythonhosted.org/packages/a6/00/45c62a7f7e34da92a25804f813ebe05c88aa9e0c25e5cb5a7d23dd7450e3/ruff-0.14.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6987ebe0501ae4f4308d7d24e2d0fe3d7a98430f5adfd0f1fead050a740a3a77", size = 13371961, upload-time = "2025-12-18T19:29:04.991Z" }, + { url = "https://files.pythonhosted.org/packages/40/31/a5906d60f0405f7e57045a70f2d57084a93ca7425f22e1d66904769d1628/ruff-0.14.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16a01dfb7b9e4eee556fbfd5392806b1b8550c9b4a9f6acd3dbe6812b193c70a", size = 13275629, upload-time = "2025-12-18T19:29:21.381Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/61c0087df21894cf9d928dc04bcd4fb10e8b2e8dca7b1a276ba2155b2002/ruff-0.14.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7165d31a925b7a294465fa81be8c12a0e9b60fb02bf177e79067c867e71f8b1f", size = 14029234, upload-time = "2025-12-18T19:29:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/44/84/77d911bee3b92348b6e5dab5a0c898d87084ea03ac5dc708f46d88407def/ruff-0.14.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c561695675b972effb0c0a45db233f2c816ff3da8dcfbe7dfc7eed625f218935", size = 15449890, upload-time = "2025-12-18T19:28:53.573Z" }, + { url = "https://files.pythonhosted.org/packages/e9/36/480206eaefa24a7ec321582dda580443a8f0671fdbf6b1c80e9c3e93a16a/ruff-0.14.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bb98fcbbc61725968893682fd4df8966a34611239c9fd07a1f6a07e7103d08e", size = 15123172, upload-time = "2025-12-18T19:29:23.453Z" }, + { url = "https://files.pythonhosted.org/packages/5c/38/68e414156015ba80cef5473d57919d27dfb62ec804b96180bafdeaf0e090/ruff-0.14.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f24b47993a9d8cb858429e97bdf8544c78029f09b520af615c1d261bf827001d", size = 14460260, upload-time = "2025-12-18T19:29:27.808Z" }, + { url = "https://files.pythonhosted.org/packages/b3/19/9e050c0dca8aba824d67cc0db69fb459c28d8cd3f6855b1405b3f29cc91d/ruff-0.14.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59aabd2e2c4fd614d2862e7939c34a532c04f1084476d6833dddef4afab87e9f", size = 14229978, upload-time = "2025-12-18T19:29:11.32Z" }, + { url = "https://files.pythonhosted.org/packages/51/eb/e8dd1dd6e05b9e695aa9dd420f4577debdd0f87a5ff2fedda33c09e9be8c/ruff-0.14.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:213db2b2e44be8625002dbea33bb9c60c66ea2c07c084a00d55732689d697a7f", size = 14338036, upload-time = "2025-12-18T19:29:09.184Z" }, + { url = "https://files.pythonhosted.org/packages/6a/12/f3e3a505db7c19303b70af370d137795fcfec136d670d5de5391e295c134/ruff-0.14.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b914c40ab64865a17a9a5b67911d14df72346a634527240039eb3bd650e5979d", size = 13264051, upload-time = "2025-12-18T19:29:13.431Z" }, + { url = "https://files.pythonhosted.org/packages/08/64/8c3a47eaccfef8ac20e0484e68e0772013eb85802f8a9f7603ca751eb166/ruff-0.14.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1484983559f026788e3a5c07c81ef7d1e97c1c78ed03041a18f75df104c45405", size = 13283998, upload-time = "2025-12-18T19:29:06.994Z" }, + { url = "https://files.pythonhosted.org/packages/12/84/534a5506f4074e5cc0529e5cd96cfc01bb480e460c7edf5af70d2bcae55e/ruff-0.14.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c70427132db492d25f982fffc8d6c7535cc2fd2c83fc8888f05caaa248521e60", size = 13601891, upload-time = "2025-12-18T19:28:55.811Z" }, + { url = "https://files.pythonhosted.org/packages/0d/1e/14c916087d8598917dbad9b2921d340f7884824ad6e9c55de948a93b106d/ruff-0.14.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5bcf45b681e9f1ee6445d317ce1fa9d6cba9a6049542d1c3d5b5958986be8830", size = 14336660, upload-time = "2025-12-18T19:29:16.531Z" }, ] [[package]] @@ -2863,74 +2094,65 @@ dependencies = [ { name = "pyasn1", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pyasn1-modules", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/07/a5/dfc752b979067947261dbbf2543470c58efe735c3c1301dd870ef27830ee/service_identity-24.2.0.tar.gz", hash = "sha256:b8683ba13f0d39c6cd5d625d2c5f65421d6d707b013b375c355751557cbe8e09", size = 39245 } +sdist = { url = "https://files.pythonhosted.org/packages/07/a5/dfc752b979067947261dbbf2543470c58efe735c3c1301dd870ef27830ee/service_identity-24.2.0.tar.gz", hash = "sha256:b8683ba13f0d39c6cd5d625d2c5f65421d6d707b013b375c355751557cbe8e09", size = 39245, upload-time = "2024-10-26T07:21:57.736Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/08/2c/ca6dd598b384bc1ce581e24aaae0f2bed4ccac57749d5c3befbb5e742081/service_identity-24.2.0-py3-none-any.whl", hash = "sha256:6b047fbd8a84fd0bb0d55ebce4031e400562b9196e1e0d3e0fe2b8a59f6d4a85", size = 11364 }, + { url = "https://files.pythonhosted.org/packages/08/2c/ca6dd598b384bc1ce581e24aaae0f2bed4ccac57749d5c3befbb5e742081/service_identity-24.2.0-py3-none-any.whl", hash = "sha256:6b047fbd8a84fd0bb0d55ebce4031e400562b9196e1e0d3e0fe2b8a59f6d4a85", size = 11364, upload-time = "2024-10-26T07:21:56.302Z" }, ] [[package]] name = "setuptools" -version = "75.6.0" +version = "80.9.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/54/292f26c208734e9a7f067aea4a7e282c080750c4546559b58e2e45413ca0/setuptools-75.6.0.tar.gz", hash = "sha256:8199222558df7c86216af4f84c30e9b34a61d8ba19366cc914424cdbd28252f6", size = 1337429 } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/55/21/47d163f615df1d30c094f6c8bbb353619274edccf0327b185cc2493c2c33/setuptools-75.6.0-py3-none-any.whl", hash = "sha256:ce74b49e8f7110f9bf04883b730f4765b774ef3ef28f722cce7c273d253aaf7d", size = 1224032 }, + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, ] [[package]] name = "sgmllib3k" version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9e/bd/3704a8c3e0942d711c1299ebf7b9091930adae6675d7c8f476a7ce48653c/sgmllib3k-1.0.0.tar.gz", hash = "sha256:7868fb1c8bfa764c1ac563d3cf369c381d1325d36124933a726f29fcdaa812e9", size = 5750 } +sdist = { url = "https://files.pythonhosted.org/packages/9e/bd/3704a8c3e0942d711c1299ebf7b9091930adae6675d7c8f476a7ce48653c/sgmllib3k-1.0.0.tar.gz", hash = "sha256:7868fb1c8bfa764c1ac563d3cf369c381d1325d36124933a726f29fcdaa812e9", size = 5750, upload-time = "2010-08-24T14:33:52.445Z" } [[package]] name = "six" version = "1.17.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, -] - -[[package]] -name = "sniffio" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] [[package]] name = "snowballstemmer" -version = "2.2.0" +version = "3.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/44/7b/af302bebf22c749c56c9c3e8ae13190b5b5db37a33d9068652e8f73b7089/snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1", size = 86699 } +sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", size = 93002 }, + { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" }, ] [[package]] name = "sonic-client" version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/29/47/5c356456e5dc3ba3f52d88a6b4d0661bdbe44a6a2340b3ca04005504c8ab/sonic-client-1.0.0.tar.gz", hash = "sha256:fe324c7354670488ed84847f6a6727d3cb5fb3675cb9b61396dcf5720e5aca66", size = 8645 } +sdist = { url = "https://files.pythonhosted.org/packages/29/47/5c356456e5dc3ba3f52d88a6b4d0661bdbe44a6a2340b3ca04005504c8ab/sonic-client-1.0.0.tar.gz", hash = "sha256:fe324c7354670488ed84847f6a6727d3cb5fb3675cb9b61396dcf5720e5aca66", size = 8645, upload-time = "2023-06-01T13:41:16.354Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/12/e98f8533a5c5b28271be79b38e0648a69e4068907568a435276532bb2871/sonic_client-1.0.0-py3-none-any.whl", hash = "sha256:291bf292861e97a2dd765ff0c8754ea9631383680d31a63ec3da6f5aa5f4beda", size = 8440 }, + { url = "https://files.pythonhosted.org/packages/9d/12/e98f8533a5c5b28271be79b38e0648a69e4068907568a435276532bb2871/sonic_client-1.0.0-py3-none-any.whl", hash = "sha256:291bf292861e97a2dd765ff0c8754ea9631383680d31a63ec3da6f5aa5f4beda", size = 8440, upload-time = "2023-06-01T13:41:14.504Z" }, ] [[package]] name = "soupsieve" -version = "2.6" +version = "2.8.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +sdist = { url = "https://files.pythonhosted.org/packages/89/23/adf3796d740536d63a6fbda113d07e60c734b6ed5d3058d1e47fc0495e47/soupsieve-2.8.1.tar.gz", hash = "sha256:4cf733bc50fa805f5df4b8ef4740fc0e0fa6218cf3006269afd3f9d6d80fd350", size = 117856, upload-time = "2025-12-18T13:50:34.655Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, + { url = "https://files.pythonhosted.org/packages/48/f3/b67d6ea49ca9154453b6d70b34ea22f3996b9fa55da105a79d8732227adc/soupsieve-2.8.1-py3-none-any.whl", hash = "sha256:a11fe2a6f3d76ab3cf2de04eb339c1be5b506a8a47f2ceb6d139803177f85434", size = 36710, upload-time = "2025-12-18T13:50:33.267Z" }, ] [[package]] name = "sphinx" -version = "8.1.3" +version = "8.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "alabaster", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2941,6 +2163,7 @@ dependencies = [ { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pygments", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, + { name = "roman-numerals-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "snowballstemmer", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinxcontrib-applehelp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinxcontrib-devhelp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -2948,11 +2171,10 @@ dependencies = [ { name = "sphinxcontrib-jsmath", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinxcontrib-qthelp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinxcontrib-serializinghtml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611 } +sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125 }, + { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" }, ] [[package]] @@ -2961,12 +2183,11 @@ version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "astroid", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, - { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/17/5f/5350046d1aa1a56b063ae08b9ad871025335c9d55fe2372896ea48711da9/sphinx_autodoc2-0.5.0.tar.gz", hash = "sha256:7d76044aa81d6af74447080182b6868c7eb066874edc835e8ddf810735b6565a", size = 115077 } +sdist = { url = "https://files.pythonhosted.org/packages/17/5f/5350046d1aa1a56b063ae08b9ad871025335c9d55fe2372896ea48711da9/sphinx_autodoc2-0.5.0.tar.gz", hash = "sha256:7d76044aa81d6af74447080182b6868c7eb066874edc835e8ddf810735b6565a", size = 115077, upload-time = "2023-11-27T07:27:51.407Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl", hash = "sha256:e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", size = 43385 }, + { url = "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl", hash = "sha256:e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", size = 43385, upload-time = "2023-11-27T07:27:49.929Z" }, ] [[package]] @@ -2978,36 +2199,36 @@ dependencies = [ { name = "sphinx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "sphinxcontrib-jquery", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/91/44/c97faec644d29a5ceddd3020ae2edffa69e7d00054a8c7a6021e82f20335/sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85", size = 7620463 } +sdist = { url = "https://files.pythonhosted.org/packages/91/44/c97faec644d29a5ceddd3020ae2edffa69e7d00054a8c7a6021e82f20335/sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85", size = 7620463, upload-time = "2024-11-13T11:06:04.545Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/77/46e3bac77b82b4df5bb5b61f2de98637724f246b4966cfc34bc5895d852a/sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13", size = 7655561 }, + { url = "https://files.pythonhosted.org/packages/85/77/46e3bac77b82b4df5bb5b61f2de98637724f246b4966cfc34bc5895d852a/sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13", size = 7655561, upload-time = "2024-11-13T11:06:02.094Z" }, ] [[package]] name = "sphinxcontrib-applehelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053 } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300 }, + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, ] [[package]] name = "sphinxcontrib-devhelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967 } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530 }, + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, ] [[package]] name = "sphinxcontrib-htmlhelp" version = "2.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617 } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705 }, + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, ] [[package]] @@ -3017,45 +2238,45 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "sphinx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331 } +sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331, upload-time = "2023-03-14T15:01:01.944Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104 }, + { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104, upload-time = "2023-03-14T15:01:00.356Z" }, ] [[package]] name = "sphinxcontrib-jsmath" version = "1.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787 } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071 }, + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, ] [[package]] name = "sphinxcontrib-qthelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165 } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743 }, + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, ] [[package]] name = "sphinxcontrib-serializinghtml" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080 } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072 }, + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, ] [[package]] name = "sqlparse" -version = "0.5.3" +version = "0.5.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e5/40/edede8dd6977b0d3da179a342c198ed100dd2aba4be081861ee5911e4da4/sqlparse-0.5.3.tar.gz", hash = "sha256:09f67787f56a0b16ecdbde1bfc7f5d9c3371ca683cfeaa8e6ff60b4807ec9272", size = 84999 } +sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/5c/bfd6bd0bf979426d405cc6e71eceb8701b148b16c21d2dc3c261efc61c7b/sqlparse-0.5.3-py3-none-any.whl", hash = "sha256:cf2196ed3418f3ba5de6af7e82c694a9fbdbfecccdfc72e281548517081f16ca", size = 44415 }, + { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" }, ] [[package]] @@ -3067,86 +2288,50 @@ dependencies = [ { name = "executing", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "pure-eval", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, ] [[package]] name = "supervisor" -version = "4.2.5" +version = "4.3.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ce/37/517989b05849dd6eaa76c148f24517544704895830a50289cbbf53c7efb9/supervisor-4.2.5.tar.gz", hash = "sha256:34761bae1a23c58192281a5115fb07fbf22c9b0133c08166beffc70fed3ebc12", size = 466073 } +sdist = { url = "https://files.pythonhosted.org/packages/a9/b5/37e7a3706de436a8a2d75334711dad1afb4ddffab09f25e31d89e467542f/supervisor-4.3.0.tar.gz", hash = "sha256:4a2bf149adf42997e1bb44b70c43b613275ec9852c3edacca86a9166b27e945e", size = 468912, upload-time = "2025-08-23T18:25:02.418Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/7a/0ad3973941590c040475046fef37a2b08a76691e61aa59540828ee235a6e/supervisor-4.2.5-py2.py3-none-any.whl", hash = "sha256:2ecaede32fc25af814696374b79e42644ecaba5c09494c51016ffda9602d0f08", size = 319561 }, + { url = "https://files.pythonhosted.org/packages/0e/65/5e726c372da8a5e35022a94388b12252710aad0c2351699c3d76ae8dba78/supervisor-4.3.0-py2.py3-none-any.whl", hash = "sha256:0bcb763fddafba410f35cbde226aa7f8514b9fb82eb05a0c85f6588d1c13f8db", size = 320736, upload-time = "2025-08-23T18:25:00.767Z" }, ] [[package]] name = "text-unidecode" version = "1.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ab/e2/e9a00f0ccb71718418230718b3d900e71a5d16e701a3dae079a21e9cd8f8/text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93", size = 76885 } +sdist = { url = "https://files.pythonhosted.org/packages/ab/e2/e9a00f0ccb71718418230718b3d900e71a5d16e701a3dae079a21e9cd8f8/text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93", size = 76885, upload-time = "2019-08-30T21:36:45.405Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8", size = 78154 }, + { url = "https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8", size = 78154, upload-time = "2019-08-30T21:37:03.543Z" }, ] [[package]] name = "toml" version = "0.10.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253 } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588 }, -] - -[[package]] -name = "tomli" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, ] [[package]] name = "traitlets" version = "5.14.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, ] [[package]] name = "twisted" -version = "24.11.0" +version = "25.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "attrs", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, @@ -3157,9 +2342,9 @@ dependencies = [ { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, { name = "zope-interface", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/77/1c/e07af0df31229250ab58a943077e4adbd5e227d9f2ac826920416b3e5fa2/twisted-24.11.0.tar.gz", hash = "sha256:695d0556d5ec579dcc464d2856b634880ed1319f45b10d19043f2b57eb0115b5", size = 3526722 } +sdist = { url = "https://files.pythonhosted.org/packages/13/0f/82716ed849bf7ea4984c21385597c949944f0f9b428b5710f79d0afc084d/twisted-25.5.0.tar.gz", hash = "sha256:1deb272358cb6be1e3e8fc6f9c8b36f78eb0fa7c2233d2dbe11ec6fee04ea316", size = 3545725, upload-time = "2025-06-07T09:52:24.858Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/70/53/a50654eb9c63da0df2b5dca8ec27656a88b7edd798de5ffad55353203874/twisted-24.11.0-py3-none-any.whl", hash = "sha256:fe403076c71f04d5d2d789a755b687c5637ec3bcd3b2b8252d76f2ba65f54261", size = 3188667 }, + { url = "https://files.pythonhosted.org/packages/eb/66/ab7efd8941f0bc7b2bd555b0f0471bff77df4c88e0cc31120c82737fec77/twisted-25.5.0-py3-none-any.whl", hash = "sha256:8559f654d01a54a8c3efe66d533d43f383531ebf8d81d9f9ab4769d91ca15df7", size = 3204767, upload-time = "2025-06-07T09:52:21.428Z" }, ] [package.optional-dependencies] @@ -3171,280 +2356,261 @@ tls = [ [[package]] name = "txaio" -version = "23.1.1" +version = "25.12.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/51/91/bc9fd5aa84703f874dea27313b11fde505d343f3ef3ad702bddbe20bfd6e/txaio-23.1.1.tar.gz", hash = "sha256:f9a9216e976e5e3246dfd112ad7ad55ca915606b60b84a757ac769bd404ff704", size = 53704 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/67/ea9c9ddbaa3e0b4d53c91f8778a33e42045be352dc7200ed2b9aaa7dc229/txaio-25.12.2.tar.gz", hash = "sha256:9f232c21e12aa1ff52690e365b5a0ecfd42cc27a6ec86e1b92ece88f763f4b78", size = 117393, upload-time = "2025-12-09T15:03:26.527Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7d/6c/a53cc9a97c2da76d9cd83c03f377468599a28f2d4ad9fc71c3b99640e71e/txaio-23.1.1-py2.py3-none-any.whl", hash = "sha256:aaea42f8aad50e0ecfb976130ada140797e9dcb85fad2cf72b0f37f8cefcb490", size = 30512 }, -] - -[[package]] -name = "typeid-python" -version = "0.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "uuid6", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/25/c3/4d4cfcdc4a568e50b0f4702fafac66e01934ded5efc4f822ed4d38d29780/typeid_python-0.3.1.tar.gz", hash = "sha256:f96a78c5dc6d8df1d058b72598bcc2c1c5bb8d8343f53f910e074dae01458417", size = 5861 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/a6/3929b4574b02541a07b3fd61f6d2757eb263dcf606ecfb71b63d504cfd08/typeid_python-0.3.1-py3-none-any.whl", hash = "sha256:62a6747933b3323d65f0bf91c8e8c7768b0292eaf9c176fb0c934ff3a61acce5", size = 7013 }, + { url = "https://files.pythonhosted.org/packages/50/05/bdb6318120cac9bf97779674f49035e0595d894b42d4c43b60637bafdb1f/txaio-25.12.2-py3-none-any.whl", hash = "sha256:5f6cd6c6b397fc3305790d15efd46a2d5b91cdbefa96543b4f8666aeb56ba026", size = 31208, upload-time = "2025-12-09T04:30:27.811Z" }, ] [[package]] name = "types-pyyaml" -version = "6.0.12.20240917" +version = "6.0.12.20250915" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/92/7d/a95df0a11f95c8f48d7683f03e4aed1a2c0fc73e9de15cca4d38034bea1a/types-PyYAML-6.0.12.20240917.tar.gz", hash = "sha256:d1405a86f9576682234ef83bcb4e6fff7c9305c8b1fbad5e0bcd4f7dbdc9c587", size = 12381 } +sdist = { url = "https://files.pythonhosted.org/packages/7e/69/3c51b36d04da19b92f9e815be12753125bd8bc247ba0470a982e6979e71c/types_pyyaml-6.0.12.20250915.tar.gz", hash = "sha256:0f8b54a528c303f0e6f7165687dd33fafa81c807fcac23f632b63aa624ced1d3", size = 17522, upload-time = "2025-09-15T03:01:00.728Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/2c/c1d81d680997d24b0542aa336f0a65bd7835e5224b7670f33a7d617da379/types_PyYAML-6.0.12.20240917-py3-none-any.whl", hash = "sha256:392b267f1c0fe6022952462bf5d6523f31e37f6cea49b14cee7ad634b6301570", size = 15264 }, + { url = "https://files.pythonhosted.org/packages/bd/e0/1eed384f02555dde685fff1a1ac805c1c7dcb6dd019c916fe659b1c1f9ec/types_pyyaml-6.0.12.20250915-py3-none-any.whl", hash = "sha256:e7d4d9e064e89a3b3cae120b4990cd370874d2bf12fa5f46c97018dd5d3c9ab6", size = 20338, upload-time = "2025-09-15T03:00:59.218Z" }, ] [[package]] name = "typing-extensions" -version = "4.12.2" +version = "4.15.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, ] [[package]] name = "tzdata" -version = "2024.2" +version = "2025.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 } +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 }, + { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" }, ] [[package]] name = "tzlocal" -version = "5.2" +version = "5.3.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/04/d3/c19d65ae67636fe63953b20c2e4a8ced4497ea232c43ff8d01db16de8dc0/tzlocal-5.2.tar.gz", hash = "sha256:8d399205578f1a9342816409cc1e46a93ebd5755e39ea2d85334bea911bf0e6e", size = 30201 } +sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload-time = "2025-03-05T21:17:41.549Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/97/3f/c4c51c55ff8487f2e6d0e618dba917e3c3ee2caae6cf0fbb59c9b1876f2e/tzlocal-5.2-py3-none-any.whl", hash = "sha256:49816ef2fe65ea8ac19d19aa7a1ae0551c834303d5014c6d5a62e4cbda8047b8", size = 17859 }, + { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" }, +] + +[[package]] +name = "u-msgpack-python" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/9d/a40411a475e7d4838994b7f6bcc6bfca9acc5b119ce3a7503608c4428b49/u-msgpack-python-2.8.0.tar.gz", hash = "sha256:b801a83d6ed75e6df41e44518b4f2a9c221dc2da4bcd5380e3a0feda520bc61a", size = 18167, upload-time = "2023-05-18T09:28:12.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/5e/512aeb40fd819f4660d00f96f5c7371ee36fc8c6b605128c5ee59e0b28c6/u_msgpack_python-2.8.0-py2.py3-none-any.whl", hash = "sha256:1d853d33e78b72c4228a2025b4db28cda81214076e5b0422ed0ae1b1b2bb586a", size = 10590, upload-time = "2023-05-18T09:28:10.323Z" }, ] [[package]] name = "uc-micro-py" version = "1.0.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043 } +sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229 }, + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, ] [[package]] -name = "ulid-py" -version = "1.1.0" +name = "ujson" +version = "5.11.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/53/d14a8ec344048e21431821cb49e9a6722384f982b889c2dd449428dbdcc1/ulid-py-1.1.0.tar.gz", hash = "sha256:dc6884be91558df077c3011b9fb0c87d1097cb8fc6534b11f310161afd5738f0", size = 22514 } +sdist = { url = "https://files.pythonhosted.org/packages/43/d9/3f17e3c5773fb4941c68d9a37a47b1a79c9649d6c56aefbed87cc409d18a/ujson-5.11.0.tar.gz", hash = "sha256:e204ae6f909f099ba6b6b942131cee359ddda2b6e4ea39c12eb8b991fe2010e0", size = 7156583, upload-time = "2025-08-20T11:57:02.452Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/42/7c/a12c879fe6c2b136a718c142115ff99397fbf62b4929d970d58ae386d55f/ulid_py-1.1.0-py2.py3-none-any.whl", hash = "sha256:b56a0f809ef90d6020b21b89a87a48edc7c03aea80e5ed5174172e82d76e3987", size = 25753 }, + { url = "https://files.pythonhosted.org/packages/28/08/4518146f4984d112764b1dfa6fb7bad691c44a401adadaa5e23ccd930053/ujson-5.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:65724738c73645db88f70ba1f2e6fb678f913281804d5da2fd02c8c5839af302", size = 55462, upload-time = "2025-08-20T11:56:04.873Z" }, + { url = "https://files.pythonhosted.org/packages/29/37/2107b9a62168867a692654d8766b81bd2fd1e1ba13e2ec90555861e02b0c/ujson-5.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29113c003ca33ab71b1b480bde952fbab2a0b6b03a4ee4c3d71687cdcbd1a29d", size = 53246, upload-time = "2025-08-20T11:56:06.054Z" }, + { url = "https://files.pythonhosted.org/packages/9b/f8/25583c70f83788edbe3ca62ce6c1b79eff465d78dec5eb2b2b56b3e98b33/ujson-5.11.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c44c703842024d796b4c78542a6fcd5c3cb948b9fc2a73ee65b9c86a22ee3638", size = 57631, upload-time = "2025-08-20T11:56:07.374Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ca/19b3a632933a09d696f10dc1b0dfa1d692e65ad507d12340116ce4f67967/ujson-5.11.0-cp314-cp314-manylinux_2_24_i686.manylinux_2_28_i686.whl", hash = "sha256:e750c436fb90edf85585f5c62a35b35082502383840962c6983403d1bd96a02c", size = 59877, upload-time = "2025-08-20T11:56:08.534Z" }, + { url = "https://files.pythonhosted.org/packages/55/7a/4572af5324ad4b2bfdd2321e898a527050290147b4ea337a79a0e4e87ec7/ujson-5.11.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f278b31a7c52eb0947b2db55a5133fbc46b6f0ef49972cd1a80843b72e135aba", size = 57363, upload-time = "2025-08-20T11:56:09.758Z" }, + { url = "https://files.pythonhosted.org/packages/7b/71/a2b8c19cf4e1efe53cf439cdf7198ac60ae15471d2f1040b490c1f0f831f/ujson-5.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ab2cb8351d976e788669c8281465d44d4e94413718af497b4e7342d7b2f78018", size = 1036394, upload-time = "2025-08-20T11:56:11.168Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3e/7b98668cba3bb3735929c31b999b374ebc02c19dfa98dfebaeeb5c8597ca/ujson-5.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:090b4d11b380ae25453100b722d0609d5051ffe98f80ec52853ccf8249dfd840", size = 1195837, upload-time = "2025-08-20T11:56:12.6Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ea/8870f208c20b43571a5c409ebb2fe9b9dba5f494e9e60f9314ac01ea8f78/ujson-5.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:80017e870d882d5517d28995b62e4e518a894f932f1e242cbc802a2fd64d365c", size = 1088837, upload-time = "2025-08-20T11:56:14.15Z" }, + { url = "https://files.pythonhosted.org/packages/6e/cd/e9809b064a89fe5c4184649adeb13c1b98652db3f8518980b04227358574/ujson-5.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:de6e88f62796372fba1de973c11138f197d3e0e1d80bcb2b8aae1e826096d433", size = 55759, upload-time = "2025-08-20T11:56:18.882Z" }, + { url = "https://files.pythonhosted.org/packages/1b/be/ae26a6321179ebbb3a2e2685b9007c71bcda41ad7a77bbbe164005e956fc/ujson-5.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:49e56ef8066f11b80d620985ae36869a3ff7e4b74c3b6129182ec5d1df0255f3", size = 53634, upload-time = "2025-08-20T11:56:20.012Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/fb4a220ee6939db099f4cfeeae796ecb91e7584ad4d445d4ca7f994a9135/ujson-5.11.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1a325fd2c3a056cf6c8e023f74a0c478dd282a93141356ae7f16d5309f5ff823", size = 58547, upload-time = "2025-08-20T11:56:21.175Z" }, + { url = "https://files.pythonhosted.org/packages/bd/f8/fc4b952b8f5fea09ea3397a0bd0ad019e474b204cabcb947cead5d4d1ffc/ujson-5.11.0-cp314-cp314t-manylinux_2_24_i686.manylinux_2_28_i686.whl", hash = "sha256:a0af6574fc1d9d53f4ff371f58c96673e6d988ed2b5bf666a6143c782fa007e9", size = 60489, upload-time = "2025-08-20T11:56:22.342Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e5/af5491dfda4f8b77e24cf3da68ee0d1552f99a13e5c622f4cef1380925c3/ujson-5.11.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10f29e71ecf4ecd93a6610bd8efa8e7b6467454a363c3d6416db65de883eb076", size = 58035, upload-time = "2025-08-20T11:56:23.92Z" }, + { url = "https://files.pythonhosted.org/packages/c4/09/0945349dd41f25cc8c38d78ace49f14c5052c5bbb7257d2f466fa7bdb533/ujson-5.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1a0a9b76a89827a592656fe12e000cf4f12da9692f51a841a4a07aa4c7ecc41c", size = 1037212, upload-time = "2025-08-20T11:56:25.274Z" }, + { url = "https://files.pythonhosted.org/packages/49/44/8e04496acb3d5a1cbee3a54828d9652f67a37523efa3d3b18a347339680a/ujson-5.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b16930f6a0753cdc7d637b33b4e8f10d5e351e1fb83872ba6375f1e87be39746", size = 1196500, upload-time = "2025-08-20T11:56:27.517Z" }, + { url = "https://files.pythonhosted.org/packages/64/ae/4bc825860d679a0f208a19af2f39206dfd804ace2403330fdc3170334a2f/ujson-5.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:04c41afc195fd477a59db3a84d5b83a871bd648ef371cf8c6f43072d89144eef", size = 1089487, upload-time = "2025-08-20T11:56:29.07Z" }, ] [[package]] name = "urllib3" -version = "2.2.3" +version = "2.6.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 } +sdist = { url = "https://files.pythonhosted.org/packages/1e/24/a2a2ed9addd907787d7aa0355ba36a6cadf1768b934c652ea78acbd59dcd/urllib3-2.6.2.tar.gz", hash = "sha256:016f9c98bb7e98085cb2b4b17b87d2c702975664e4f060c6532e64d1c1a5e797", size = 432930, upload-time = "2025-12-11T15:56:40.252Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 }, + { url = "https://files.pythonhosted.org/packages/6d/b9/4095b668ea3678bf6a0af005527f39de12fb026516fb3df17495a733b7f8/urllib3-2.6.2-py3-none-any.whl", hash = "sha256:ec21cddfe7724fc7cb4ba4bea7aa8e2ef36f607a4bab81aa6ce42a13dc3f03dd", size = 131182, upload-time = "2025-12-11T15:56:38.584Z" }, ] [[package]] -name = "uuid6" -version = "2024.7.10" +name = "useful-types" +version = "0.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2c/56/2560a9f1ccab9e12b1b3478a3c870796cf4d8ee5652bb19b61751cced14a/uuid6-2024.7.10.tar.gz", hash = "sha256:2d29d7f63f593caaeea0e0d0dd0ad8129c9c663b29e19bdf882e864bedf18fb0", size = 8705 } +dependencies = [ + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/92/d6/0d6db1f8766e9b5e7ec259666c40ceae6bbb9326caf50e08717639e167b7/useful_types-0.2.1.tar.gz", hash = "sha256:870a0bcc8fcb7d0b2f14055438c1cab7e248fded942b0943a4d7019e7fbbdacd", size = 4748, upload-time = "2024-04-20T08:58:15.195Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d3/3e/4ae6af487ce5781ed71d5fe10aca72e7cbc4d4f45afc31b120287082a8dd/uuid6-2024.7.10-py3-none-any.whl", hash = "sha256:93432c00ba403751f722829ad21759ff9db051dea140bf81493271e8e4dd18b7", size = 6376 }, + { url = "https://files.pythonhosted.org/packages/13/23/c194fd6c6258727f694e22b106c262c7d2678049dbc2d2045743e235f43a/useful_types-0.2.1-py3-none-any.whl", hash = "sha256:0dca32763d7271b5c8c7c395c44c10d09dba47a41aec97dcb085041ad096e0e9", size = 5382, upload-time = "2024-04-20T08:58:13.759Z" }, ] [[package]] name = "uv" -version = "0.5.10" +version = "0.9.18" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/a0/647e502063b6c1ee64f5fe58505076caedf2b6a4fd24bbe38eb7e7a23147/uv-0.5.10.tar.gz", hash = "sha256:502d9d10f5f139c850b1f6085a0c5719d49dd39d767504ce7c4245b47531f156", size = 2513057 } +sdist = { url = "https://files.pythonhosted.org/packages/e3/03/1afff9e6362dc9d3a9e03743da0a4b4c7a0809f859c79eb52bbae31ea582/uv-0.9.18.tar.gz", hash = "sha256:17b5502f7689c4dc1fdeee9d8437a9a6664dcaa8476e70046b5f4753559533f5", size = 3824466, upload-time = "2025-12-16T15:45:11.81Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/42/35f42c0d890572133b5ed617f366e1c1c28c5d4aba81a0caf4ff75c8b0c9/uv-0.5.10-py3-none-linux_armv6l.whl", hash = "sha256:064e977957e61aaaf7215bbd8f8566bcb22d7662c8adc929d039010fdb686436", size = 14481162 }, - { url = "https://files.pythonhosted.org/packages/d8/1b/e86d376d80448c58600c3308b7deae313ae5a4fa9029b25ff14b2fcbee6c/uv-0.5.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:06eb14988a75cc178241747a9437d23faad7d62e2d9b955db7e8a8098853341a", size = 14445673 }, - { url = "https://files.pythonhosted.org/packages/20/50/0ffe3502b63b7d06ebbf0fa11045eee03f6ac4a2ce94f088c59db46f2c32/uv-0.5.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5890ca6703c371cecc88c2a7bf32fc47187a865fc577df0d40d390fcbdec76f0", size = 13374766 }, - { url = "https://files.pythonhosted.org/packages/83/35/8106990031683010f78f96e7fdeb0dda0015df816cd75f5b9cf1239cc67c/uv-0.5.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:adc0dad56118127b3a1cc0126149a9b8c643fd4e4c5fa37be6af4bd84d33d30c", size = 13683595 }, - { url = "https://files.pythonhosted.org/packages/65/56/3ec5334a2f50eaf51ded43cb95e69791af17f517f697ba0882e44a1a3f0e/uv-0.5.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b61812ee4765f07db02ff616d4aac9c514857c0648459242a286243fe92d6223", size = 14262614 }, - { url = "https://files.pythonhosted.org/packages/ee/fb/6df4ac2d19acfcdf7674e2c39a606bb737ca7e262fea1ae863f20a967672/uv-0.5.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:326603d44454a8856a5660bb406e99194f3c8d2cc4504c97c99871da59575022", size = 14947540 }, - { url = "https://files.pythonhosted.org/packages/f0/74/952778975f708db5ded85b464e7db5f200e825001e4b56c783232b4d4e17/uv-0.5.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:fa8607cc07cc9e666e531a9533b02d45bbb376ae314721434643c328298709b4", size = 15463566 }, - { url = "https://files.pythonhosted.org/packages/b1/98/168f200969d39a723e94fe6908745cd4963fb5ff028a594a40f8d41d997f/uv-0.5.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:27f27eba58b9a71c3a7905ca966c69adf5a4a1df1dd14ef4d064c40cbaabc49e", size = 15377097 }, - { url = "https://files.pythonhosted.org/packages/82/d4/9ed375bc0b57fa1a243b37f032f7e5ab4db073d2b8375ef473a70623c9af/uv-0.5.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e0b91598e67d8c1228b47894a61fffb9d82caf8f1080bb9f21df49530118db6", size = 19846554 }, - { url = "https://files.pythonhosted.org/packages/7e/c1/ba8b73015503844d80a049bedbd3ce360ff19bdd5f141d4aa863470761e2/uv-0.5.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8bc47bd623b1f8fa883b7afbf480286b946512d9ac7bf23105e7d63ef702ea7b", size = 14968017 }, - { url = "https://files.pythonhosted.org/packages/ab/cd/093521211c71dca0ae260f7f5aa0445dc8ccb8c336c8e633aff08142ed75/uv-0.5.10-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:253a02e03bf83bc0ec4e17242f54a4af2fef6191fcfb392b2613defd2b2a2f89", size = 13895243 }, - { url = "https://files.pythonhosted.org/packages/e9/65/c95a2aee826bdc174ffb15b27cdfae7c4fb0e67c9b0585344ce269dada0a/uv-0.5.10-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:936759d8de8f78969756ee2b1558b4e9bd4b059922d0840cdd162a190c95ac50", size = 14235179 }, - { url = "https://files.pythonhosted.org/packages/60/8b/88ccf2b3b511c61f3cf74f8065bf3ea16242163674e3d320bb50feed52b9/uv-0.5.10-py3-none-musllinux_1_1_i686.whl", hash = "sha256:7337ed40bae6f37d9335bf7f83bb43d08b6c141212b1ca3b15a9194c4d438ffe", size = 14600891 }, - { url = "https://files.pythonhosted.org/packages/a8/23/8b4ab856369c2c4a3abf1c309090349b3e7710ec76fad816538f6a371f89/uv-0.5.10-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:68a6b992b7ebae9f3fa2f395348c95e6f05745246b067a26e7597a6730fcb690", size = 15082104 }, + { url = "https://files.pythonhosted.org/packages/26/9c/92fad10fcee8ea170b66442d95fd2af308fe9a107909ded4b3cc384fdc69/uv-0.9.18-py3-none-linux_armv6l.whl", hash = "sha256:e9e4915bb280c1f79b9a1c16021e79f61ed7c6382856ceaa99d53258cb0b4951", size = 21345538, upload-time = "2025-12-16T15:45:13.992Z" }, + { url = "https://files.pythonhosted.org/packages/81/b1/b0e5808e05acb54aa118c625d9f7b117df614703b0cbb89d419d03d117f3/uv-0.9.18-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d91abfd2649987996e3778729140c305ef0f6ff5909f55aac35c3c372544a24f", size = 20439572, upload-time = "2025-12-16T15:45:26.397Z" }, + { url = "https://files.pythonhosted.org/packages/b7/0b/9487d83adf5b7fd1e20ced33f78adf84cb18239c3d7e91f224cedba46c08/uv-0.9.18-py3-none-macosx_11_0_arm64.whl", hash = "sha256:cf33f4146fd97e94cdebe6afc5122208eea8c55b65ca4127f5a5643c9717c8b8", size = 18952907, upload-time = "2025-12-16T15:44:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/58/92/c8f7ae8900eff8e4ce1f7826d2e1e2ad5a95a5f141abdb539865aff79930/uv-0.9.18-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:edf965e9a5c55f74020ac82285eb0dfe7fac4f325ad0a7afc816290269ecfec1", size = 20772495, upload-time = "2025-12-16T15:45:29.614Z" }, + { url = "https://files.pythonhosted.org/packages/5a/28/9831500317c1dd6cde5099e3eb3b22b88ac75e47df7b502f6aef4df5750e/uv-0.9.18-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae10a941bd7ca1ee69edbe3998c34dce0a9fc2d2406d98198343daf7d2078493", size = 20949623, upload-time = "2025-12-16T15:44:57.482Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ff/1fe1ffa69c8910e54dd11f01fb0765d4fd537ceaeb0c05fa584b6b635b82/uv-0.9.18-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a1669a95b588f613b13dd10e08ced6d5bcd79169bba29a2240eee87532648790", size = 21920580, upload-time = "2025-12-16T15:44:39.009Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ee/eed3ec7679ee80e16316cfc95ed28ef6851700bcc66edacfc583cbd2cc47/uv-0.9.18-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:11e1e406590d3159138288203a41ff8a8904600b8628a57462f04ff87d62c477", size = 23491234, upload-time = "2025-12-16T15:45:32.59Z" }, + { url = "https://files.pythonhosted.org/packages/78/58/64b15df743c79ad03ea7fbcbd27b146ba16a116c57f557425dd4e44d6684/uv-0.9.18-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e82078d3c622cb4c60da87f156168ffa78b9911136db7ffeb8e5b0a040bf30e", size = 23095438, upload-time = "2025-12-16T15:45:17.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/6d/3d3dae71796961603c3871699e10d6b9de2e65a3c327b58d4750610a5f93/uv-0.9.18-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704abaf6e76b4d293fc1f24bef2c289021f1df0de9ed351f476cbbf67a7edae0", size = 22140992, upload-time = "2025-12-16T15:44:45.527Z" }, + { url = "https://files.pythonhosted.org/packages/31/91/1042d0966a30e937df500daed63e1f61018714406ce4023c8a6e6d2dcf7c/uv-0.9.18-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3332188fd8d96a68e5001409a52156dced910bf1bc41ec3066534cffcd46eb68", size = 22229626, upload-time = "2025-12-16T15:45:20.712Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1f/0a4a979bb2bf6e1292cc57882955bf1d7757cad40b1862d524c59c2a2ad8/uv-0.9.18-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:b7295e6d505f1fd61c54b1219e3b18e11907396333a9fa61cefe489c08fc7995", size = 20896524, upload-time = "2025-12-16T15:45:06.799Z" }, + { url = "https://files.pythonhosted.org/packages/a5/3c/24f92e56af00cac7d9bed2888d99a580f8093c8745395ccf6213bfccf20b/uv-0.9.18-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:62ea0e518dd4ab76e6f06c0f43a25898a6342a3ecf996c12f27f08eb801ef7f1", size = 22077340, upload-time = "2025-12-16T15:44:51.271Z" }, + { url = "https://files.pythonhosted.org/packages/9c/3e/73163116f748800e676bf30cee838448e74ac4cc2f716c750e1705bc3fe4/uv-0.9.18-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:8bd073e30030211ba01206caa57b4d63714e1adee2c76a1678987dd52f72d44d", size = 20932956, upload-time = "2025-12-16T15:45:00.3Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/a26990b51a17de1ffe41fbf2e30de3a98f0e0bce40cc60829fb9d9ed1a8a/uv-0.9.18-py3-none-musllinux_1_1_i686.whl", hash = "sha256:f248e013d10e1fc7a41f94310628b4a8130886b6d683c7c85c42b5b36d1bcd02", size = 21357247, upload-time = "2025-12-16T15:45:23.575Z" }, + { url = "https://files.pythonhosted.org/packages/5f/20/b6ba14fdd671e9237b22060d7422aba4a34503e3e42d914dbf925eff19aa/uv-0.9.18-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:17bedf2b0791e87d889e1c7f125bd5de77e4b7579aec372fa06ba832e07c957e", size = 22443585, upload-time = "2025-12-16T15:44:42.213Z" }, ] [[package]] name = "viztracer" -version = "1.0.0" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "objprint", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e6/2e/ab21b6a1b908d3fce74e95ec3156224059345cf208c5b319778ebecc55b6/viztracer-1.0.0.tar.gz", hash = "sha256:8377376fb255ee1543a2ce97bc65c68c26238d754aff9c4a049bb05948ece53b", size = 14268442 } +sdist = { url = "https://files.pythonhosted.org/packages/9c/ab/94ae463cd4e386f143e3520a274856c4f2b4858d7ae30aa223ae25e9a2e5/viztracer-1.1.1.tar.gz", hash = "sha256:dcd4b5ddcc3a40ee79a584406d984cb4d40bc3301a6c9015d8949d4445fe9346", size = 15667892, upload-time = "2025-11-11T00:03:17.751Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/16/19/392fdaca028168947fa4f8e1c3ff0f9e90efe677b2cca7e27f06035c0791/viztracer-1.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8afadbf11d00e0ed1bded79eed85dc5a3b1d216ed6408dd3a54b51e3de52a3e", size = 14434889 }, - { url = "https://files.pythonhosted.org/packages/52/b4/1bbeae877076e751ea21d7622890dbec08e514ea908ab1c1ba55c316dd77/viztracer-1.0.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:2efe54d15e596da08ea00fe960cbc3c36a0beda452d5ba16286c077e61b4cfa1", size = 14435132 }, - { url = "https://files.pythonhosted.org/packages/a8/88/07a55b0eceac2df32427c37152e5cb4c18725029a5e1675118bad7aee6c2/viztracer-1.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df48a755f386cc083847a23ac1d24bb817b3626feae4e62a9f3a548dc524ddbe", size = 14548468 }, - { url = "https://files.pythonhosted.org/packages/59/73/47a00d94e8198ee2e31c27bac842d4770f6bf684c4a854460e1e5c1aac56/viztracer-1.0.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1249a94a2aabae1046ec4fef16b5f22a5d60da5aef688daa9e39dac8b4d0dd52", size = 14543393 }, - { url = "https://files.pythonhosted.org/packages/3f/17/1cc5ed3f6336b95db344128f2f53ffe76ee72d8d2083f4055d69099ec25c/viztracer-1.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74399b78fa3faf0b2270dc80b2c991c3d1520a9c8777a05b987cb7e0a4637ad0", size = 14553455 }, - { url = "https://files.pythonhosted.org/packages/4e/9c/33ee5380714db02339d64aadc11c77f7cfa5cfadcdb3118bbd126b7f06d6/viztracer-1.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cc0a1a2cccba761532fdaddeafa5e91d42c8763b959024b57d7e6f28e6f09312", size = 14434658 }, - { url = "https://files.pythonhosted.org/packages/7b/8f/d9ad7f0757d96c6f4fe548c5b532bcd530582e4d902ad332d8c2173626f2/viztracer-1.0.0-cp311-cp311-macosx_11_0_x86_64.whl", hash = "sha256:8e80da2946f4d4e333b393e037eeed1a1278992dc89dc00085fa70c65b22d3f4", size = 14434945 }, - { url = "https://files.pythonhosted.org/packages/7c/56/e1e8e91fc408ec3877c1d2eb507cc46909d40f3ecdfe6eecb59c0a63deeb/viztracer-1.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d12fec746ca5c8873eb46b6c90bf74519d2e1661631c3c7581babb909538ba41", size = 14547146 }, - { url = "https://files.pythonhosted.org/packages/f5/03/1bce6cf73b20e77eb4039838f7d344eba0eef3c042e2c76973dd7634c5b6/viztracer-1.0.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f6564e3da201c79e7488f6fc9299f6a9a3d7ef2d3bcaaf5a8dd670443a76cba9", size = 14542105 }, - { url = "https://files.pythonhosted.org/packages/f1/99/fcd02197ae1effa69d5c9f9a60d3f2341e54ae42900c9589d2f339327d31/viztracer-1.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0775786813fa70564ae6bf0d494573badbbec7f59f49c4826c627892df020509", size = 14552263 }, - { url = "https://files.pythonhosted.org/packages/35/a5/7531d0b30e47063e89c9c4db68ec70b6de3c45f4d2b040e873b584b84a80/viztracer-1.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5dcbc0aafed06c0334d3d93d228775d54dba157e563a3672ed3b05ef74491dce", size = 14434883 }, - { url = "https://files.pythonhosted.org/packages/cb/3e/2c98897178c598945d4ad959c6c0d0d5841c780af603fcd3f09469edd683/viztracer-1.0.0-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:038416558de92ab742fc96d8a44676aa1872d9d71b5b912b76fa3905d24e7b37", size = 14435715 }, - { url = "https://files.pythonhosted.org/packages/64/63/e6aacf97b0af693dcb0c9c985b31e0effd6b0d740f0f97f5371125c0204f/viztracer-1.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cba82eeab28cdb9c66bb22c6a7c3a41edf91cce2eaa87f2d3a1e124595dde815", size = 14553393 }, - { url = "https://files.pythonhosted.org/packages/e5/15/9a7025916fce59636df024b56ed3230424fb3bd0dfdff02189305f40fd0b/viztracer-1.0.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6b374d2634ff0d2917647e2bb1ed8ba0d7e21c245512ef4dd160f48a6427dd2c", size = 14550264 }, - { url = "https://files.pythonhosted.org/packages/ea/a9/303961befbb2f0118d1ed34672426613241eb581b836e262c255293c22bd/viztracer-1.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe3faacb11c525844393f42b0d74fe40fe4f9707b3ef0893e7258830e97d9ed", size = 14562061 }, - { url = "https://files.pythonhosted.org/packages/4f/32/187d40965fb829997b67d21af140bfc3295127a1f9c2d557210ad084de6c/viztracer-1.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:84d607aa4a3b44f25ec25af0c08ea204c523059e5bb43d4cfb3b2b3e7a021842", size = 14434881 }, - { url = "https://files.pythonhosted.org/packages/59/d9/cb3bde47b8af8f7fb40a804ca9a3065d4b377e751e0d82a9b25d7e5a67be/viztracer-1.0.0-cp313-cp313-macosx_11_0_x86_64.whl", hash = "sha256:d83f36d19dcd074d4dbf10caa3d69c769ef2665504bb54bc99a96c8e08baa8ec", size = 14435756 }, - { url = "https://files.pythonhosted.org/packages/0c/1d/c9fda134bcca3a55463c4b3595b3250a113cf4d06444d72ba9f8bd1ba2fb/viztracer-1.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d52c71a881ba9e22087e9cfab979edcf9c7175bb9c7b3b0fdfa29d59df00e719", size = 14553467 }, - { url = "https://files.pythonhosted.org/packages/9f/56/9044bf2fd1d7c5b031ba28798a6c5da361e03977bed67b9c1634a392e2e9/viztracer-1.0.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7a8570f545b6dc32556aa9d808be80ffc3e5d219c85f78eaccb14240c0ce2d83", size = 14550061 }, - { url = "https://files.pythonhosted.org/packages/84/ae/d8cd56e189437313de8faa9cc4bf0e67164f882cf65f94caab4b591dc8c2/viztracer-1.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be3325893a26d35a12b271c81159d1bc46a1442655691c71e8728abdef5617f7", size = 14562127 }, - { url = "https://files.pythonhosted.org/packages/e4/bd/3ac6bcfe80607c726373ea8cc24bcf2139e2d2ef566924cfec3c8285dc08/viztracer-1.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a3bce333887e4ad1a435af0089a522edb2c8af9d665bd6a8fba0cc13b0686b88", size = 14437787 }, - { url = "https://files.pythonhosted.org/packages/80/32/cd0f3ea8d507f44c5e17d86a665fe97d2d27ba0f12084673a4da612c12f6/viztracer-1.0.0-cp313-cp313t-macosx_11_0_x86_64.whl", hash = "sha256:6aa8345069a6b1bd74caba08ed890b41b42e3b192e278f3f7762cf6f565d213e", size = 14438484 }, - { url = "https://files.pythonhosted.org/packages/ff/31/d91c501936438411c08f066ddfee58d6676957ed46780e11d0cd053371e4/viztracer-1.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3419af0a23450e5ff998de0b7fa3e240ca9df4f190f354c8d23773d616c5c311", size = 14601235 }, - { url = "https://files.pythonhosted.org/packages/f9/f5/78e6df5bbeff3158da3a44556f35d5d7b9324eb0e7c6dbfb72aac202edac/viztracer-1.0.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4ee4be0c94f67bbdf7ce10c021bf3378a8eea83ab725cb56f366c8af8a6fc36", size = 14592528 }, - { url = "https://files.pythonhosted.org/packages/08/8b/b1c538b26110f155d903d36154eb4efe936489069c5e67cdf041dc076a60/viztracer-1.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23d89ce9413b3821f71802dc385cf108e6fd3d406ec9ffc0f7eda2671fcb6995", size = 14603801 }, + { url = "https://files.pythonhosted.org/packages/d5/d7/c6f6757591a4aa24882edb0bc00c86839a6feedc9beb35909e21cd13c68f/viztracer-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b21a400091d549bf42ccd68045799406117dfdd4a5d4aeeb17cd281f7d8b7792", size = 15737837, upload-time = "2025-11-11T00:02:50.121Z" }, + { url = "https://files.pythonhosted.org/packages/9f/34/3ee13e0c7b10163f3da9b5fecd21a3450679f3440c10d7e3f7ebabfa2cc3/viztracer-1.1.1-cp314-cp314-macosx_11_0_x86_64.whl", hash = "sha256:764230fde61aa8455b2f984dce7187c30827c557de821e13b4b3f49b85c36219", size = 15736900, upload-time = "2025-11-11T00:02:52.571Z" }, + { url = "https://files.pythonhosted.org/packages/5d/db/bde529061a0b345354642809d12b18b68401054d6286651b1b0ef81eeff9/viztracer-1.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a28d08a3b68e71d4b12dda0eefbb13cdbf0b6bf38f9f1fd402731ebbcb81a03c", size = 15856038, upload-time = "2025-11-11T00:02:55.15Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4a/61fb597bb114f5869f02cca49d146e25ec87bf4d27d8d4db492b4ead01b5/viztracer-1.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc3a40aeae924d3d0d5e3e48553316672da95773908a3164a8af56a231ce8d9c", size = 15863381, upload-time = "2025-11-11T00:02:57.208Z" }, + { url = "https://files.pythonhosted.org/packages/5e/f1/b0f4a67c82d9dd97da991dae06daca817e8af86fd05f0ce21661ef158701/viztracer-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b0fb8fd937eaf9af43a64dbcfb27d8b7776d4fb26ac4e6c71c02901e485cbb6e", size = 15740556, upload-time = "2025-11-11T00:03:04.163Z" }, + { url = "https://files.pythonhosted.org/packages/1e/92/970464370c009edf4e13637efd56f4f3355916d0087738902b463e0f1200/viztracer-1.1.1-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:a68299ad6570e4f1d5e389aadd6ab05d7c473b751326feebdc5326bd835ddd03", size = 15739794, upload-time = "2025-11-11T00:03:06.24Z" }, + { url = "https://files.pythonhosted.org/packages/98/b2/d030f0f95009fa3705f0765559f8b4203c3832635d83aed17f636fed324d/viztracer-1.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f083779f7a4e6f55a4d5992973db83eca4f0cd660addb925960b61b1eea2539", size = 15905552, upload-time = "2025-11-11T00:03:08.342Z" }, + { url = "https://files.pythonhosted.org/packages/f1/89/957d4a14852ad8c38bcb99878e2c189652221afed41e83333167b2370d24/viztracer-1.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4c17277e4269356aa636e9eda8bac728768e61720c4667d4c5a877fa30ad511", size = 15907141, upload-time = "2025-11-11T00:03:10.753Z" }, ] [[package]] name = "w3lib" -version = "2.2.1" +version = "2.3.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cc/dd/8d080c3bf19f4e853433193e0ffd894d9f5c5a55c11d7283038ee822a0db/w3lib-2.2.1.tar.gz", hash = "sha256:756ff2d94c64e41c8d7c0c59fea12a5d0bc55e33a531c7988b4a163deb9b07dd", size = 49603 } +sdist = { url = "https://files.pythonhosted.org/packages/bf/7d/1172cfaa1e29beb9bf938e484c122b3bdc82e8e37b17a4f753ba6d6e009f/w3lib-2.3.1.tar.gz", hash = "sha256:5c8ac02a3027576174c2b61eb9a2170ba1b197cae767080771b6f1febda249a4", size = 49531, upload-time = "2025-01-27T14:22:10.453Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/df/d6/ff9000e85b820ab36c0a93f2c8a4b334a80821b631a56c252aed2d0bd2d3/w3lib-2.2.1-py3-none-any.whl", hash = "sha256:e56d81c6a6bf507d7039e0c95745ab80abd24b465eb0f248af81e3eaa46eb510", size = 21948 }, + { url = "https://files.pythonhosted.org/packages/58/dd/56f0d8af71e475ed194d702f8b4cf9cea812c95e82ad823d239023c6558c/w3lib-2.3.1-py3-none-any.whl", hash = "sha256:9ccd2ae10c8c41c7279cd8ad4fe65f834be894fe7bfdd7304b991fd69325847b", size = 21751, upload-time = "2025-01-27T14:22:09.421Z" }, ] [[package]] name = "wcwidth" -version = "0.2.13" +version = "0.2.14" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" }, ] [[package]] name = "wheel" version = "0.45.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8a/98/2d9906746cdc6a6ef809ae6338005b3f21bb568bea3165cfc6a243fdc25c/wheel-0.45.1.tar.gz", hash = "sha256:661e1abd9198507b1409a20c02106d9670b2576e916d58f520316666abca6729", size = 107545 } +sdist = { url = "https://files.pythonhosted.org/packages/8a/98/2d9906746cdc6a6ef809ae6338005b3f21bb568bea3165cfc6a243fdc25c/wheel-0.45.1.tar.gz", hash = "sha256:661e1abd9198507b1409a20c02106d9670b2576e916d58f520316666abca6729", size = 107545, upload-time = "2024-11-23T00:18:23.513Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/2c/87f3254fd8ffd29e4c02732eee68a83a1d3c346ae39bc6822dcbcb697f2b/wheel-0.45.1-py3-none-any.whl", hash = "sha256:708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248", size = 72494 }, + { url = "https://files.pythonhosted.org/packages/0b/2c/87f3254fd8ffd29e4c02732eee68a83a1d3c346ae39bc6822dcbcb697f2b/wheel-0.45.1-py3-none-any.whl", hash = "sha256:708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248", size = 72494, upload-time = "2024-11-23T00:18:21.207Z" }, ] [[package]] name = "wrapt" -version = "1.17.0" +version = "1.17.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/24/a1/fc03dca9b0432725c2e8cdbf91a349d2194cf03d8523c124faebe581de09/wrapt-1.17.0.tar.gz", hash = "sha256:16187aa2317c731170a88ef35e8937ae0f533c402872c1ee5e6d079fcf320801", size = 55542 } +sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/f9/85220321e9bb1a5f72ccce6604395ae75fcb463d87dad0014dc1010bd1f1/wrapt-1.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a0c23b8319848426f305f9cb0c98a6e32ee68a36264f45948ccf8e7d2b941f8", size = 38766 }, - { url = "https://files.pythonhosted.org/packages/ff/71/ff624ff3bde91ceb65db6952cdf8947bc0111d91bd2359343bc2fa7c57fd/wrapt-1.17.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1ca5f060e205f72bec57faae5bd817a1560fcfc4af03f414b08fa29106b7e2d", size = 83262 }, - { url = "https://files.pythonhosted.org/packages/9f/0a/814d4a121a643af99cfe55a43e9e6dd08f4a47cdac8e8f0912c018794715/wrapt-1.17.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e185ec6060e301a7e5f8461c86fb3640a7beb1a0f0208ffde7a65ec4074931df", size = 74990 }, - { url = "https://files.pythonhosted.org/packages/cd/c7/b8c89bf5ca5c4e6a2d0565d149d549cdb4cffb8916d1d1b546b62fb79281/wrapt-1.17.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb90765dd91aed05b53cd7a87bd7f5c188fcd95960914bae0d32c5e7f899719d", size = 82712 }, - { url = "https://files.pythonhosted.org/packages/19/7c/5977aefa8460906c1ff914fd42b11cf6c09ded5388e46e1cc6cea4ab15e9/wrapt-1.17.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:879591c2b5ab0a7184258274c42a126b74a2c3d5a329df16d69f9cee07bba6ea", size = 81705 }, - { url = "https://files.pythonhosted.org/packages/ae/e7/233402d7bd805096bb4a8ec471f5a141421a01de3c8c957cce569772c056/wrapt-1.17.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fce6fee67c318fdfb7f285c29a82d84782ae2579c0e1b385b7f36c6e8074fffb", size = 74636 }, - { url = "https://files.pythonhosted.org/packages/93/81/b6c32d8387d9cfbc0134f01585dee7583315c3b46dfd3ae64d47693cd078/wrapt-1.17.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0698d3a86f68abc894d537887b9bbf84d29bcfbc759e23f4644be27acf6da301", size = 81299 }, - { url = "https://files.pythonhosted.org/packages/0e/40/def56538acddc2f764c157d565b9f989072a1d2f2a8e384324e2e104fc7d/wrapt-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:74bf625b1b4caaa7bad51d9003f8b07a468a704e0644a700e936c357c17dd45a", size = 38766 }, - { url = "https://files.pythonhosted.org/packages/89/e2/8c299f384ae4364193724e2adad99f9504599d02a73ec9199bf3f406549d/wrapt-1.17.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f2a28eb35cf99d5f5bd12f5dd44a0f41d206db226535b37b0c60e9da162c3ed", size = 83730 }, - { url = "https://files.pythonhosted.org/packages/29/ef/fcdb776b12df5ea7180d065b28fa6bb27ac785dddcd7202a0b6962bbdb47/wrapt-1.17.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81b1289e99cf4bad07c23393ab447e5e96db0ab50974a280f7954b071d41b489", size = 75470 }, - { url = "https://files.pythonhosted.org/packages/55/b5/698bd0bf9fbb3ddb3a2feefbb7ad0dea1205f5d7d05b9cbab54f5db731aa/wrapt-1.17.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f2939cd4a2a52ca32bc0b359015718472d7f6de870760342e7ba295be9ebaf9", size = 83168 }, - { url = "https://files.pythonhosted.org/packages/ce/07/701a5cee28cb4d5df030d4b2649319e36f3d9fdd8000ef1d84eb06b9860d/wrapt-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6a9653131bda68a1f029c52157fd81e11f07d485df55410401f745007bd6d339", size = 82307 }, - { url = "https://files.pythonhosted.org/packages/42/92/c48ba92cda6f74cb914dc3c5bba9650dc80b790e121c4b987f3a46b028f5/wrapt-1.17.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4e4b4385363de9052dac1a67bfb535c376f3d19c238b5f36bddc95efae15e12d", size = 75101 }, - { url = "https://files.pythonhosted.org/packages/8a/0a/9276d3269334138b88a2947efaaf6335f61d547698e50dff672ade24f2c6/wrapt-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bdf62d25234290db1837875d4dceb2151e4ea7f9fff2ed41c0fde23ed542eb5b", size = 81835 }, - { url = "https://files.pythonhosted.org/packages/85/82/518605474beafff11f1a34759f6410ab429abff9f7881858a447e0d20712/wrapt-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:89fc28495896097622c3fc238915c79365dd0ede02f9a82ce436b13bd0ab7569", size = 38904 }, - { url = "https://files.pythonhosted.org/packages/80/6c/17c3b2fed28edfd96d8417c865ef0b4c955dc52c4e375d86f459f14340f1/wrapt-1.17.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:875d240fdbdbe9e11f9831901fb8719da0bd4e6131f83aa9f69b96d18fae7504", size = 88622 }, - { url = "https://files.pythonhosted.org/packages/4a/11/60ecdf3b0fd3dca18978d89acb5d095a05f23299216e925fcd2717c81d93/wrapt-1.17.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5ed16d95fd142e9c72b6c10b06514ad30e846a0d0917ab406186541fe68b451", size = 80920 }, - { url = "https://files.pythonhosted.org/packages/d2/50/dbef1a651578a3520d4534c1e434989e3620380c1ad97e309576b47f0ada/wrapt-1.17.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18b956061b8db634120b58f668592a772e87e2e78bc1f6a906cfcaa0cc7991c1", size = 89170 }, - { url = "https://files.pythonhosted.org/packages/44/a2/78c5956bf39955288c9e0dd62e807b308c3aa15a0f611fbff52aa8d6b5ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:daba396199399ccabafbfc509037ac635a6bc18510ad1add8fd16d4739cdd106", size = 86748 }, - { url = "https://files.pythonhosted.org/packages/99/49/2ee413c78fc0bdfebe5bee590bf3becdc1fab0096a7a9c3b5c9666b2415f/wrapt-1.17.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4d63f4d446e10ad19ed01188d6c1e1bb134cde8c18b0aa2acfd973d41fcc5ada", size = 79734 }, - { url = "https://files.pythonhosted.org/packages/c0/8c/4221b7b270e36be90f0930fe15a4755a6ea24093f90b510166e9ed7861ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8a5e7cc39a45fc430af1aefc4d77ee6bad72c5bcdb1322cfde852c15192b8bd4", size = 87552 }, - { url = "https://files.pythonhosted.org/packages/67/9c/38294e1bb92b055222d1b8b6591604ca4468b77b1250f59c15256437644f/wrapt-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:714c12485aa52efbc0fc0ade1e9ab3a70343db82627f90f2ecbc898fdf0bb181", size = 38904 }, - { url = "https://files.pythonhosted.org/packages/78/b6/76597fb362cbf8913a481d41b14b049a8813cd402a5d2f84e57957c813ae/wrapt-1.17.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da427d311782324a376cacb47c1a4adc43f99fd9d996ffc1b3e8529c4074d393", size = 88608 }, - { url = "https://files.pythonhosted.org/packages/bc/69/b500884e45b3881926b5f69188dc542fb5880019d15c8a0df1ab1dfda1f7/wrapt-1.17.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba1739fb38441a27a676f4de4123d3e858e494fac05868b7a281c0a383c098f4", size = 80879 }, - { url = "https://files.pythonhosted.org/packages/52/31/f4cc58afe29eab8a50ac5969963010c8b60987e719c478a5024bce39bc42/wrapt-1.17.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e711fc1acc7468463bc084d1b68561e40d1eaa135d8c509a65dd534403d83d7b", size = 89119 }, - { url = "https://files.pythonhosted.org/packages/aa/9c/05ab6bf75dbae7a9d34975fb6ee577e086c1c26cde3b6cf6051726d33c7c/wrapt-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:140ea00c87fafc42739bd74a94a5a9003f8e72c27c47cd4f61d8e05e6dec8721", size = 86778 }, - { url = "https://files.pythonhosted.org/packages/0e/6c/4b8d42e3db355603d35fe5c9db79c28f2472a6fd1ccf4dc25ae46739672a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:73a96fd11d2b2e77d623a7f26e004cc31f131a365add1ce1ce9a19e55a1eef90", size = 79793 }, - { url = "https://files.pythonhosted.org/packages/69/23/90e3a2ee210c0843b2c2a49b3b97ffcf9cad1387cb18cbeef9218631ed5a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0b48554952f0f387984da81ccfa73b62e52817a4386d070c75e4db7d43a28c4a", size = 87606 }, - { url = "https://files.pythonhosted.org/packages/ce/b5/251165c232d87197a81cd362eeb5104d661a2dd3aa1f0b33e4bf61dda8b8/wrapt-1.17.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:17fcf043d0b4724858f25b8826c36e08f9fb2e475410bece0ec44a22d533da9b", size = 40146 }, - { url = "https://files.pythonhosted.org/packages/89/33/1e1bdd3e866eeb73d8c4755db1ceb8a80d5bd51ee4648b3f2247adec4e67/wrapt-1.17.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4a557d97f12813dc5e18dad9fa765ae44ddd56a672bb5de4825527c847d6379", size = 113444 }, - { url = "https://files.pythonhosted.org/packages/9f/7c/94f53b065a43f5dc1fbdd8b80fd8f41284315b543805c956619c0b8d92f0/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0229b247b0fc7dee0d36176cbb79dbaf2a9eb7ecc50ec3121f40ef443155fb1d", size = 101246 }, - { url = "https://files.pythonhosted.org/packages/62/5d/640360baac6ea6018ed5e34e6e80e33cfbae2aefde24f117587cd5efd4b7/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8425cfce27b8b20c9b89d77fb50e368d8306a90bf2b6eef2cdf5cd5083adf83f", size = 109320 }, - { url = "https://files.pythonhosted.org/packages/e3/cf/6c7a00ae86a2e9482c91170aefe93f4ccda06c1ac86c4de637c69133da59/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9c900108df470060174108012de06d45f514aa4ec21a191e7ab42988ff42a86c", size = 110193 }, - { url = "https://files.pythonhosted.org/packages/cd/cc/aa718df0d20287e8f953ce0e2f70c0af0fba1d3c367db7ee8bdc46ea7003/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4e547b447073fc0dbfcbff15154c1be8823d10dab4ad401bdb1575e3fdedff1b", size = 100460 }, - { url = "https://files.pythonhosted.org/packages/f7/16/9f3ac99fe1f6caaa789d67b4e3c562898b532c250769f5255fa8b8b93983/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:914f66f3b6fc7b915d46c1cc424bc2441841083de01b90f9e81109c9759e43ab", size = 106347 }, - { url = "https://files.pythonhosted.org/packages/4b/d9/a8ba5e9507a9af1917285d118388c5eb7a81834873f45df213a6fe923774/wrapt-1.17.0-py3-none-any.whl", hash = "sha256:d2c63b93548eda58abf5188e505ffed0229bf675f7c3090f8e36ad55b8cbc371", size = 23592 }, + { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" }, + { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" }, + { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" }, + { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" }, + { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" }, + { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" }, + { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" }, + { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" }, + { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" }, + { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" }, ] [[package]] name = "xlrd" -version = "2.0.1" +version = "2.0.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/b3/19a2540d21dea5f908304375bd43f5ed7a4c28a370dc9122c565423e6b44/xlrd-2.0.1.tar.gz", hash = "sha256:f72f148f54442c6b056bf931dbc34f986fd0c3b0b6b5a58d013c9aef274d0c88", size = 100259 } +sdist = { url = "https://files.pythonhosted.org/packages/07/5a/377161c2d3538d1990d7af382c79f3b2372e880b65de21b01b1a2b78691e/xlrd-2.0.2.tar.gz", hash = "sha256:08b5e25de58f21ce71dc7db3b3b8106c1fa776f3024c54e45b45b374e89234c9", size = 100167, upload-time = "2025-06-14T08:46:39.039Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/0c/c2a72d51fe56e08a08acc85d13013558a2d793028ae7385448a6ccdfae64/xlrd-2.0.1-py2.py3-none-any.whl", hash = "sha256:6a33ee89877bd9abc1158129f6e94be74e2679636b8a205b43b85206c3f0bbdd", size = 96531 }, + { url = "https://files.pythonhosted.org/packages/1a/62/c8d562e7766786ba6587d09c5a8ba9f718ed3fa8af7f4553e8f91c36f302/xlrd-2.0.2-py2.py3-none-any.whl", hash = "sha256:ea762c3d29f4cca48d82df517b6d89fbce4db3107f9d78713e48cd321d5c9aa9", size = 96555, upload-time = "2025-06-14T08:46:37.766Z" }, ] [[package]] name = "xmltodict" -version = "0.14.2" +version = "1.0.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/50/05/51dcca9a9bf5e1bce52582683ce50980bcadbc4fa5143b9f2b19ab99958f/xmltodict-0.14.2.tar.gz", hash = "sha256:201e7c28bb210e374999d1dde6382923ab0ed1a8a5faeece48ab525b7810a553", size = 51942 } +sdist = { url = "https://files.pythonhosted.org/packages/6a/aa/917ceeed4dbb80d2f04dbd0c784b7ee7bba8ae5a54837ef0e5e062cd3cfb/xmltodict-1.0.2.tar.gz", hash = "sha256:54306780b7c2175a3967cad1db92f218207e5bc1aba697d887807c0fb68b7649", size = 25725, upload-time = "2025-09-17T21:59:26.459Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d6/45/fc303eb433e8a2a271739c98e953728422fa61a3c1f36077a49e395c972e/xmltodict-0.14.2-py2.py3-none-any.whl", hash = "sha256:20cc7d723ed729276e808f26fb6b3599f786cbc37e06c65e192ba77c40f20aac", size = 9981 }, + { url = "https://files.pythonhosted.org/packages/c0/20/69a0e6058bc5ea74892d089d64dfc3a62ba78917ec5e2cfa70f7c92ba3a5/xmltodict-1.0.2-py3-none-any.whl", hash = "sha256:62d0fddb0dcbc9f642745d8bbf4d81fd17d6dfaec5a15b5c1876300aad92af0d", size = 13893, upload-time = "2025-09-17T21:59:24.859Z" }, +] + +[[package]] +name = "yt-dlp" +version = "2025.12.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/14/77/db924ebbd99d0b2b571c184cb08ed232cf4906c6f9b76eed763cd2c84170/yt_dlp-2025.12.8.tar.gz", hash = "sha256:b773c81bb6b71cb2c111cfb859f453c7a71cf2ef44eff234ff155877184c3e4f", size = 3088947, upload-time = "2025-12-08T00:16:01.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/2f/98c3596ad923f8efd32c90dca62e241e8ad9efcebf20831173c357042ba0/yt_dlp-2025.12.8-py3-none-any.whl", hash = "sha256:36e2584342e409cfbfa0b5e61448a1c5189e345cf4564294456ee509e7d3e065", size = 3291464, upload-time = "2025-12-08T00:15:58.556Z" }, ] [[package]] name = "zipp" -version = "3.21.0" +version = "3.23.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, ] [[package]] name = "zope-interface" -version = "7.2" +version = "8.1.1" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/30/93/9210e7606be57a2dfc6277ac97dcc864fd8d39f142ca194fdc186d596fda/zope.interface-7.2.tar.gz", hash = "sha256:8b49f1a3d1ee4cdaf5b32d2e738362c7f5e40ac8b46dd7d1a65e82a4872728fe", size = 252960 } +sdist = { url = "https://files.pythonhosted.org/packages/71/c9/5ec8679a04d37c797d343f650c51ad67d178f0001c363e44b6ac5f97a9da/zope_interface-8.1.1.tar.gz", hash = "sha256:51b10e6e8e238d719636a401f44f1e366146912407b58453936b781a19be19ec", size = 254748, upload-time = "2025-11-15T08:32:52.404Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/71/e6177f390e8daa7e75378505c5ab974e0bf59c1d3b19155638c7afbf4b2d/zope.interface-7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ce290e62229964715f1011c3dbeab7a4a1e4971fd6f31324c4519464473ef9f2", size = 208243 }, - { url = "https://files.pythonhosted.org/packages/52/db/7e5f4226bef540f6d55acfd95cd105782bc6ee044d9b5587ce2c95558a5e/zope.interface-7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:05b910a5afe03256b58ab2ba6288960a2892dfeef01336dc4be6f1b9ed02ab0a", size = 208759 }, - { url = "https://files.pythonhosted.org/packages/28/ea/fdd9813c1eafd333ad92464d57a4e3a82b37ae57c19497bcffa42df673e4/zope.interface-7.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:550f1c6588ecc368c9ce13c44a49b8d6b6f3ca7588873c679bd8fd88a1b557b6", size = 254922 }, - { url = "https://files.pythonhosted.org/packages/3b/d3/0000a4d497ef9fbf4f66bb6828b8d0a235e690d57c333be877bec763722f/zope.interface-7.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0ef9e2f865721553c6f22a9ff97da0f0216c074bd02b25cf0d3af60ea4d6931d", size = 249367 }, - { url = "https://files.pythonhosted.org/packages/3e/e5/0b359e99084f033d413419eff23ee9c2bd33bca2ca9f4e83d11856f22d10/zope.interface-7.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27f926f0dcb058211a3bb3e0e501c69759613b17a553788b2caeb991bed3b61d", size = 254488 }, - { url = "https://files.pythonhosted.org/packages/98/7d/2e8daf0abea7798d16a58f2f3a2bf7588872eee54ac119f99393fdd47b65/zope.interface-7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1909f52a00c8c3dcab6c4fad5d13de2285a4b3c7be063b239b8dc15ddfb73bd2", size = 208776 }, - { url = "https://files.pythonhosted.org/packages/a0/2a/0c03c7170fe61d0d371e4c7ea5b62b8cb79b095b3d630ca16719bf8b7b18/zope.interface-7.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:80ecf2451596f19fd607bb09953f426588fc1e79e93f5968ecf3367550396b22", size = 209296 }, - { url = "https://files.pythonhosted.org/packages/49/b4/451f19448772b4a1159519033a5f72672221e623b0a1bd2b896b653943d8/zope.interface-7.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:033b3923b63474800b04cba480b70f6e6243a62208071fc148354f3f89cc01b7", size = 260997 }, - { url = "https://files.pythonhosted.org/packages/65/94/5aa4461c10718062c8f8711161faf3249d6d3679c24a0b81dd6fc8ba1dd3/zope.interface-7.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a102424e28c6b47c67923a1f337ede4a4c2bba3965b01cf707978a801fc7442c", size = 255038 }, - { url = "https://files.pythonhosted.org/packages/9f/aa/1a28c02815fe1ca282b54f6705b9ddba20328fabdc37b8cf73fc06b172f0/zope.interface-7.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:25e6a61dcb184453bb00eafa733169ab6d903e46f5c2ace4ad275386f9ab327a", size = 259806 }, - { url = "https://files.pythonhosted.org/packages/68/0b/c7516bc3bad144c2496f355e35bd699443b82e9437aa02d9867653203b4a/zope.interface-7.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:086ee2f51eaef1e4a52bd7d3111a0404081dadae87f84c0ad4ce2649d4f708b7", size = 208959 }, - { url = "https://files.pythonhosted.org/packages/a2/e9/1463036df1f78ff8c45a02642a7bf6931ae4a38a4acd6a8e07c128e387a7/zope.interface-7.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21328fcc9d5b80768bf051faa35ab98fb979080c18e6f84ab3f27ce703bce465", size = 209357 }, - { url = "https://files.pythonhosted.org/packages/07/a8/106ca4c2add440728e382f1b16c7d886563602487bdd90004788d45eb310/zope.interface-7.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6dd02ec01f4468da0f234da9d9c8545c5412fef80bc590cc51d8dd084138a89", size = 264235 }, - { url = "https://files.pythonhosted.org/packages/fc/ca/57286866285f4b8a4634c12ca1957c24bdac06eae28fd4a3a578e30cf906/zope.interface-7.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8e7da17f53e25d1a3bde5da4601e026adc9e8071f9f6f936d0fe3fe84ace6d54", size = 259253 }, - { url = "https://files.pythonhosted.org/packages/96/08/2103587ebc989b455cf05e858e7fbdfeedfc3373358320e9c513428290b1/zope.interface-7.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cab15ff4832580aa440dc9790b8a6128abd0b88b7ee4dd56abacbc52f212209d", size = 264702 }, - { url = "https://files.pythonhosted.org/packages/c6/3b/e309d731712c1a1866d61b5356a069dd44e5b01e394b6cb49848fa2efbff/zope.interface-7.2-cp313-cp313-macosx_10_9_x86_64.whl", hash = "sha256:3e0350b51e88658d5ad126c6a57502b19d5f559f6cb0a628e3dc90442b53dd98", size = 208961 }, - { url = "https://files.pythonhosted.org/packages/49/65/78e7cebca6be07c8fc4032bfbb123e500d60efdf7b86727bb8a071992108/zope.interface-7.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:15398c000c094b8855d7d74f4fdc9e73aa02d4d0d5c775acdef98cdb1119768d", size = 209356 }, - { url = "https://files.pythonhosted.org/packages/11/b1/627384b745310d082d29e3695db5f5a9188186676912c14b61a78bbc6afe/zope.interface-7.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:802176a9f99bd8cc276dcd3b8512808716492f6f557c11196d42e26c01a69a4c", size = 264196 }, - { url = "https://files.pythonhosted.org/packages/b8/f6/54548df6dc73e30ac6c8a7ff1da73ac9007ba38f866397091d5a82237bd3/zope.interface-7.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb23f58a446a7f09db85eda09521a498e109f137b85fb278edb2e34841055398", size = 259237 }, - { url = "https://files.pythonhosted.org/packages/b6/66/ac05b741c2129fdf668b85631d2268421c5cd1a9ff99be1674371139d665/zope.interface-7.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a71a5b541078d0ebe373a81a3b7e71432c61d12e660f1d67896ca62d9628045b", size = 264696 }, + { url = "https://files.pythonhosted.org/packages/b9/f5/44efbd98ba06cb937fce7a69fcd7a78c4ac7aa4e1ad2125536801376d2d0/zope_interface-8.1.1-cp314-cp314-macosx_10_9_x86_64.whl", hash = "sha256:da311e9d253991ca327601f47c4644d72359bac6950fbb22f971b24cd7850f8c", size = 209099, upload-time = "2025-11-15T08:37:09.395Z" }, + { url = "https://files.pythonhosted.org/packages/fd/36/a19866c09c8485c36a4c6908e1dd3f8820b41c1ee333c291157cf4cf09e7/zope_interface-8.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3fb25fca0442c7fb93c4ee40b42e3e033fef2f648730c4b7ae6d43222a3e8946", size = 209240, upload-time = "2025-11-15T08:37:10.687Z" }, + { url = "https://files.pythonhosted.org/packages/c1/28/0dbf40db772d779a4ac8d006a57ad60936d42ad4769a3d5410dcfb98f6f9/zope_interface-8.1.1-cp314-cp314-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:bac588d0742b4e35efb7c7df1dacc0397b51ed37a17d4169a38019a1cebacf0a", size = 260919, upload-time = "2025-11-15T08:37:11.838Z" }, + { url = "https://files.pythonhosted.org/packages/72/ae/650cd4c01dd1b32c26c800b2c4d852f044552c34a56fbb74d41f569cee31/zope_interface-8.1.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3d1f053d2d5e2b393e619bce1e55954885c2e63969159aa521839e719442db49", size = 264102, upload-time = "2025-11-15T08:37:13.241Z" }, + { url = "https://files.pythonhosted.org/packages/46/f0/f534a2c34c006aa090c593cd70eaf94e259fd0786f934698d81f0534d907/zope_interface-8.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:64a1ad7f4cb17d948c6bdc525a1d60c0e567b2526feb4fa38b38f249961306b8", size = 264276, upload-time = "2025-11-15T08:37:14.369Z" }, ]