atlan-application-sdk 0.1.1rc24__tar.gz → 0.1.1rc26__tar.gz

atlan_application_sdk-0.1.1rc26/.cursor/BUGBOT.md

@@ -0,0 +1,60 @@
+# Project Review Guidelines - Application SDK
+
+## Core Principles
+
+**Less Code is Better** - Prioritize simplicity, readability, and maintainability over cleverness. Every line of code is a liability that must be justified.
+
+## Critical Review Checklist
+
+### 🔍 Code Quality & Minimalism
+
+- **Necessity Check**: Is this code absolutely necessary? Can existing functionality be reused?
+- **Single Responsibility**: Does each function/class do exactly one thing well?
+- **DRY Violations**: Any repeated logic that should be extracted into shared utilities?
+- **Cognitive Load**: Can a new developer understand this change with less cognitive load?
+- **Magic Numbers/Strings**: All constants properly defined and named in @application_sdk/constants.py
+- **Spell Check**: No typos in code, comments, docstrings, or documentation
+- **Exception Handling Standards**: All exception handling must follow these principles. See detailed guidelines in [exception-handling.mdc](mdc:.cursor/rules/exception-handling.mdc).
+
+### 🏗️ Architecture & Design
+
+- **Module Boundaries**: Changes respect existing module responsibilities
+- **Error Handling**: Proper exception handling with meaningful error messages
+- **Resource Management**: Files, connections, and resources properly closed/released
+- **Async Patterns**: Proper async/await usage where applicable
+- **Configuration**: No hardcoded values; use proper configuration management
+
+### 📝 Documentation Requirements
+
+- **Docstrings**: All public functions, classes, and modules have Google-style docstrings
+- **Type Hints**: All function parameters and return values are typed
+- **Complex Logic**: Non-obvious business logic has inline comments explaining "why"
+
+### 🧪 Testing
+
+- **Testing Standards**: Testing standards are defined in [testing.mdc](mdc:.cursor/rules/testing.mdc)
+- **Test Coverage**: New code has corresponding tests (unit/integration/e2e as appropriate)
+- **Edge Cases**: Error conditions and boundary cases are tested
+- **Mock Strategy**: External dependencies properly mocked/isolated
+- **Test Naming**: Test names clearly describe the scenario being tested
+
+### 🔒 Security & Performance
+
+- **Input Validation**: All external inputs validated and sanitized
+- **Secrets Management**: No secrets in code; proper credential handling
+- **SQL Injection**: Parameterized queries used for all SQL operations
+- **Performance Standards**: All performance considerations must follow these principles. See detailed guidelines in [performance.mdc](mdc:.cursor/rules/performance.mdc).
+- **Memory Management**: Resources properly closed, large datasets processed in chunks
+- **DataFrame Optimization**: Appropriate dtypes, avoid unnecessary copies, use chunked processing
+- **SQL Query Efficiency**: Use LIMIT, specific columns, proper WHERE clauses, connection pooling
+- **Serialization Performance**: Use orjson for large datasets, implement compression
+- **Algorithm Efficiency**: Use appropriate data structures, avoid O(n²) when O(n) alternatives exist
+- **Caching Strategy**: Cache expensive operations and database queries
+- **Async Usage**: Use async for I/O operations, sync for CPU-bound tasks
+
+### 📊 Observability & Logging
+
+- **Logging Standards**: logging standards are defined in [logging.mdc](mdc:.cursor/rules/logging.mdc)
+- **Metrics**: Key operations include appropriate metrics
+- **Error Context**: Error logs include sufficient context for debugging
+- **Trace Information**: Critical paths include trace information

atlan_application_sdk-0.1.1rc26/.cursor/rules/exception-handling.mdc

@@ -0,0 +1,198 @@
+---
+alwaysApply: false
+globs: application_sdk/**/*.py
+---
+# Exception Handling Standards
+
+## Core Principles
+
+**Default Behavior: Re-raise Exceptions** - Exceptions should be re-raised by default unless explicitly handled for a specific reason. Silent exception swallowing is not allowed.
+
+## Critical Rules
+
+### **Exception Propagation**
+- **Rule**: Always re-raise exceptions after logging unless in non-critical operations
+- **Anti-pattern**: `except Exception as e: logger.error(f"Error: {e}")` - This swallows exceptions
+- **Correct pattern**: `except Exception as e: logger.error(f"Error: {e}"); raise`
+
+### **Specific Exception Types**
+- **Use specific exception types** instead of generic `Exception`
+- **Examples**: `ValueError`, `ConnectionError`, `TimeoutError`, `FileNotFoundError`
+- **Create custom exceptions** in `application_sdk/common/error_codes.py` for domain-specific errors
+- **Anti-pattern**: `except Exception:` - Too broad, masks real issues
+
+## Exception Handling Patterns
+
+### **✅ DO: Proper exception handling with re-raising**
+```python
+try:
+    result = some_operation()
+    return result
+except ValueError as e:
+    logger.error(f"Invalid input: {e}")
+    raise  # Re-raise to propagate the error
+except ConnectionError as e:
+    logger.error(f"Connection failed: {e}")
+    raise  # Re-raise to propagate the error
+except Exception as e:
+    logger.error(f"Unexpected error: {e}")
+    raise  # Re-raise to propagate the error
+```
+
+### **❌ DON'T: Swallowing exceptions**
+```python
+try:
+    result = some_operation()
+    return result
+except Exception as e:
+    logger.error(f"Error: {e}")
+    # Missing raise - this swallows the exception!
+```
+
+## Context-Specific Guidelines
+
+### **1. Critical Operations (Database, Network, File I/O)**
+- **Always re-raise** exceptions after logging
+- **Include context** in error messages
+- **Use specific exception types**
+
+### **2. Non-Critical Operations (Logging, Metrics, Observability)**
+- **May swallow exceptions** to prevent cascading failures
+- **Log the failure** for debugging
+- **Continue operation** if possible
+
+### **3. Resource Cleanup**
+- **Use try/finally** for guaranteed cleanup
+- **Log cleanup failures** but don't re-raise (to avoid masking original error)
+
+## Common Anti-patterns to Reject
+
+### **❌ Silent Exception Swallowing**
+```python
+try:
+    operation()
+except Exception:
+    pass  # REJECT: Silent failure
+```
+
+### **❌ Generic Exception Catching Without Re-raising**
+```python
+try:
+    operation()
+except Exception as e:
+    logger.error(f"Error: {e}")  # REJECT: Swallows exception
+```
+
+### **❌ Overly Broad Exception Handling**
+```python
+try:
+    operation()
+except Exception as e:  # REJECT: Too broad
+    logger.error(f"Error: {e}")
+    raise
+```
+
+### **❌ Exception Handling Without Context**
+```python
+try:
+    operation()
+except Exception as e:
+    logger.error(f"Error: {e}")  # REJECT: No context about what failed
+    raise
+```
+
+## Best Practices
+
+### **✅ DO: Proper exception handling with context**
+```python
+try:
+    result = database_connection.execute_query(query)
+    return result
+except ConnectionError as e:
+    logger.error(f"Database connection failed for query {query[:50]}...: {e}")
+    raise
+except ValueError as e:
+    logger.error(f"Invalid query parameters: {e}")
+    raise
+except Exception as e:
+    logger.error(f"Unexpected error during database operation: {e}")
+    raise
+```
+
+### **✅ DO: Resource cleanup with exception handling**
+```python
+file_handle = None
+try:
+    file_handle = open(filename, 'r')
+    return file_handle.read()
+except FileNotFoundError as e:
+    logger.error(f"File not found: {filename}")
+    raise
+finally:
+    if file_handle:
+        try:
+            file_handle.close()
+        except Exception as e:
+            logger.warning(f"Failed to close file {filename}: {e}")
+            # Don't re-raise cleanup errors
+```
+
+### **✅ DO: Non-critical operation exception handling**
+```python
+try:
+    metrics.record_metric("operation_success", 1)
+except Exception as e:
+    logger.warning(f"Failed to record metric: {e}")
+    # Don't re-raise for non-critical operations
+```
+
+## Module-Specific Guidelines
+
+### **Handlers (`application_sdk/handlers/`)**
+- **Critical**: Always re-raise exceptions after logging
+- **Include operation context** in error messages
+- **Use specific exception types** for different error scenarios
+
+### **Outputs (`application_sdk/outputs/`)**
+- **Critical**: Re-raise exceptions for data writing operations
+- **Non-critical**: May swallow exceptions for metrics/logging operations
+- **Resource cleanup**: Ensure files/connections are properly closed
+
+### **Inputs (`application_sdk/inputs/`)**
+- **Critical**: Re-raise exceptions for data reading operations
+- **Include file/connection context** in error messages
+- **Handle specific I/O exceptions** appropriately
+
+### **Observability (`application_sdk/observability/`)**
+- **Non-critical**: May swallow exceptions to prevent cascading failures
+- **Log all failures** for debugging
+- **Continue operation** when possible
+
+### **Workflows (`application_sdk/workflows/`)**
+- **Critical**: Re-raise exceptions to trigger workflow retry logic
+- **Include workflow context** in error messages
+- **Handle Temporal-specific exceptions** appropriately
+
+### **Server (`application_sdk/server/`)**
+- **Critical**: Re-raise exceptions to return proper HTTP error responses
+- **Include request context** in error messages
+- **Handle HTTP-specific exceptions** appropriately
+
+## Review Checklist
+
+When reviewing code, check for:
+
+1. **Exception Propagation**: Are exceptions properly re-raised when they should be?
+2. **Specific Exception Types**: Are specific exception types used instead of generic `Exception`?
+3. **Error Context**: Do error messages include sufficient context for debugging?
+4. **Resource Cleanup**: Are resources properly cleaned up in finally blocks?
+5. **Non-Critical Operations**: Are non-critical operations (logging, metrics) handled appropriately?
+6. **Custom Exceptions**: Are domain-specific exceptions defined in `error_codes.py`?
+7. **Exception Documentation**: Are exceptions documented in function docstrings?
+
+## Implementation Notes
+
+- **Custom Exceptions**: Define domain-specific exceptions in `application_sdk/common/error_codes.py`
+- **Logging**: Use `AtlanLoggerAdapter` for all logging with proper context
+- **Context**: Always include relevant context in error messages (query, filename, operation, etc.)
+- **Documentation**: Document all exceptions that functions can raise in docstrings

atlan_application_sdk-0.1.1rc26/.cursor/rules/performance.mdc

@@ -0,0 +1,294 @@
+---
+alwaysApply: false
+globs: application_sdk/**/*.py
+---
+# Performance Standards
+
+## Core Principles
+
+**Performance is a Feature** - Performance issues are bugs that affect user experience and system reliability. All code must be written with performance considerations in mind.
+
+## Critical Performance Areas
+
+### **Memory Management**
+
+#### **Memory Leaks Prevention**
+- **Rule**: Always close resources (files, connections, iterators) in finally blocks
+- **Anti-pattern**: Opening resources without proper cleanup
+- **Correct pattern**: Use context managers or try/finally
+
+**✅ DO: Proper resource management**
+```python
+# Using context manager
+with open(filename, 'r') as f:
+    data = f.read()
+
+# Using try/finally
+file_handle = None
+try:
+    file_handle = open(filename, 'r')
+    data = file_handle.read()
+finally:
+    if file_handle:
+        file_handle.close()
+```
+
+**❌ DON'T: Resource leaks**
+```python
+# REJECT: No cleanup
+file_handle = open(filename, 'r')
+data = file_handle.read()
+# Missing file_handle.close()
+```
+
+#### **Large Object Management**
+- **Rule**: Process large datasets in chunks, not all at once
+- **Anti-pattern**: Loading entire dataset into memory
+- **Correct pattern**: Use generators, iterators, or chunked processing
+
+**✅ DO: Chunked processing**
+```python
+def process_large_file(filename: str, chunk_size: int = 1000):
+    """Process large file in chunks to avoid memory issues."""
+    with open(filename, 'r') as f:
+        chunk = []
+        for line in f:
+            chunk.append(line.strip())
+            if len(chunk) >= chunk_size:
+                yield process_chunk(chunk)
+                chunk = []
+        if chunk:  # Process remaining items
+            yield process_chunk(chunk)
+```
+
+**❌ DON'T: Load everything into memory**
+```python
+# REJECT: Memory intensive
+def process_large_file(filename: str):
+    with open(filename, 'r') as f:
+        all_lines = f.readlines()  # Loads entire file into memory
+        return process_all_lines(all_lines)
+```
+
+### **DataFrame Performance**
+
+#### **Memory-Efficient DataFrame Operations**
+- **Rule**: Use appropriate data types and avoid unnecessary copies
+- **Anti-pattern**: Creating multiple copies of large DataFrames
+- **Correct pattern**: Use inplace operations and proper dtypes
+
+**✅ DO: Memory-efficient DataFrame operations**
+```python
+# Use appropriate dtypes
+df = pd.read_csv('large_file.csv', dtype={
+    'id': 'int32',
+    'category': 'category',  # More memory efficient than object
+    'value': 'float32'
+})
+
+# Use inplace operations when possible
+df.dropna(inplace=True)  # Instead of df = df.dropna()
+df.reset_index(drop=True, inplace=True)
+
+# Use query() for filtering (more memory efficient)
+filtered_df = df.query('value > 100 and category == "A"')
+```
+
+**❌ DON'T: Inefficient DataFrame operations**
+```python
+# REJECT: Creates unnecessary copies
+df = df.dropna()  # Creates copy
+df = df.reset_index()  # Creates another copy
+df = df[df['value'] > 100]  # Creates another copy
+df = df[df['category'] == 'A']  # Creates another copy
+```
+
+#### **DataFrame Chunking**
+- **Rule**: Process large DataFrames in chunks
+- **Anti-pattern**: Processing entire DataFrame at once
+- **Correct pattern**: Use chunked reading and processing
+
+**✅ DO: Chunked DataFrame processing**
+```python
+def process_large_dataframe(filename: str, chunk_size: int = 10000):
+    """Process large CSV file in chunks."""
+    for chunk in pd.read_csv(filename, chunksize=chunk_size):
+        # Process each chunk
+        processed_chunk = process_chunk(chunk)
+        yield processed_chunk
+```
+
+**❌ DON'T: Load entire DataFrame**
+```python
+# REJECT: Memory intensive for large files
+df = pd.read_csv('very_large_file.csv')  # Loads entire file
+process_dataframe(df)
+```
+
+### **SQL Query Performance**
+
+#### **Query Optimization**
+- **Rule**: Write efficient SQL queries with proper indexing and limiting
+- **Anti-pattern**: SELECT * without LIMIT on large tables
+- **Correct pattern**: Use specific columns, LIMIT, and proper WHERE clauses
+
+**✅ DO: Optimized SQL queries**
+```python
+# Use specific columns instead of SELECT *
+query = "SELECT id, name, created_at FROM users WHERE status = 'active' LIMIT 1000"
+
+# Use parameterized queries for security and performance
+query = "SELECT * FROM users WHERE age > %s AND city = %s LIMIT %s"
+params = (18, 'New York', 100)
+
+# Use appropriate indexes in WHERE clauses
+query = "SELECT * FROM orders WHERE user_id = %s AND created_at > %s"
+```
+
+**❌ DON'T: Inefficient SQL queries**
+```python
+# REJECT: No LIMIT on large table
+query = "SELECT * FROM users"  # Could return millions of rows
+
+# REJECT: No WHERE clause on indexed columns
+query = "SELECT * FROM orders WHERE amount > 0"  # Should use user_id or date
+
+# REJECT: String concatenation (SQL injection risk)
+query = f"SELECT * FROM users WHERE name = '{user_input}'"
+```
+
+#### **Connection and Transaction Management**
+- **Rule**: Use connection pooling and proper transaction management
+- **Anti-pattern**: Creating new connections for each query
+- **Correct pattern**: Reuse connections and use transactions
+
+**✅ DO: Proper connection management**
+```python
+# Use connection pooling
+async def execute_queries():
+    async with get_db_connection() as conn:
+        async with conn.transaction():
+            await conn.execute("INSERT INTO logs (message) VALUES ($1)", "info")
+            await conn.execute("UPDATE counters SET value = value + 1")
+```
+
+**❌ DON'T: Poor connection management**
+```python
+# REJECT: Creating new connection for each query
+for query in queries:
+    conn = create_new_connection()  # Expensive
+    conn.execute(query)
+    conn.close()
+```
+
+### **Serialization/Deserialization Performance**
+
+#### **JSON Serialization Optimization**
+- **Rule**: Use efficient serialization libraries and avoid unnecessary conversions
+- **Anti-pattern**: Using default json module for large datasets
+- **Correct pattern**: Use orjson, ujson, or custom serializers
+
+**✅ DO: Efficient JSON serialization**
+```python
+import orjson  # Much faster than json
+
+# Use orjson for better performance
+data = orjson.dumps(large_dict, option=orjson.OPT_APPEND_NEWLINE)
+
+# Use streaming for large datasets
+def serialize_large_dataset(data_iterator):
+    for item in data_iterator:
+        yield orjson.dumps(item) + b'\n'
+```
+
+**❌ DON'T: Inefficient serialization**
+```python
+# REJECT: Using default json for large datasets
+import json
+data = json.dumps(large_dict)  # Slower than orjson
+
+# REJECT: Converting to string unnecessarily
+data = str(orjson.dumps(large_dict))  # Unnecessary conversion
+```
+
+
+### **CPU Performance**
+
+#### **Algorithm Efficiency**
+- **Rule**: Use appropriate algorithms and data structures
+- **Anti-pattern**: O(n²) algorithms when O(n) or O(log n) alternatives exist
+- **Correct pattern**: Choose efficient algorithms and data structures
+
+**✅ DO: Efficient algorithms**
+```python
+# Use set for O(1) lookups
+def find_duplicates(items):
+    seen = set()
+    duplicates = set()
+    for item in items:
+        if item in seen:
+            duplicates.add(item)
+        else:
+            seen.add(item)
+    return list(duplicates)
+
+# Use list comprehension instead of loops when appropriate
+squares = [x**2 for x in range(1000)]  # More efficient than loop
+```
+
+**❌ DON'T: Inefficient algorithms**
+```python
+# REJECT: O(n²) algorithm
+def find_duplicates(items):
+    duplicates = []
+    for i, item in enumerate(items):
+        if item in items[i+1:]:  # O(n) lookup
+            duplicates.append(item)
+    return duplicates
+```
+
+#### **Async/Await Performance**
+- **Rule**: Use async/await for I/O operations, not CPU-bound tasks
+- **Anti-pattern**: Using async for CPU-intensive operations
+- **Correct pattern**: Use async for I/O, sync for CPU-bound tasks
+
+**✅ DO: Proper async usage**
+```python
+import asyncio
+import aiofiles
+
+# Async for I/O operations
+async def read_files_async(filenames):
+    async def read_single_file(filename):
+        async with aiofiles.open(filename, 'r') as f:
+            return await f.read()
+
+    tasks = [read_single_file(filename) for filename in filenames]
+    return await asyncio.gather(*tasks)
+
+# Sync for CPU-bound operations
+def process_data_cpu_intensive(data):
+    # CPU-intensive processing
+    return [x * 2 for x in data]
+```
+
+**❌ DON'T: Misusing async**
+```python
+# REJECT: Using async for CPU-bound operations
+async def process_data_cpu_intensive(data):
+    # This should be sync
+    return [x * 2 for x in data]
+```
+
+## Performance Review Checklist
+
+When reviewing code for performance, check for:
+
+1. **Memory Management**: Are resources properly closed? Are large datasets processed in chunks?
+2. **DataFrame Operations**: Are appropriate dtypes used? Are unnecessary copies avoided?
+3. **SQL Queries**: Are queries optimized with LIMIT and proper WHERE clauses?
+4. **Serialization**: Are efficient libraries (orjson) used for large datasets?
+5. **Algorithm Efficiency**: Are appropriate data structures and algorithms used?
+6. **Async Usage**: Is async used for I/O operations, not CPU-bound tasks?
+7. **Connection Pooling**: Are database connections reused?
+8. **Batch Processing**: Are operations batched when possible?

atlan_application_sdk-0.1.1rc26/.env.example

@@ -0,0 +1,37 @@
+# refer application_sdk/constants.py for extensive list of environment configurations
+
+ATLAN_WORKFLOW_HOST=localhost
+ATLAN_WORKFLOW_PORT=7233
+ATLAN_WORKFLOW_NAMESPACE=default
+ATLAN_APPLICATION_NAME=default
+ATLAN_TENANT_ID=development
+ATLAN_WORKFLOW_UI_HOST=localhost
+ATLAN_WORKFLOW_UI_PORT=8233
+ATLAN_WORKFLOW_MAX_TIMEOUT_HOURS=1
+ATLAN_MAX_CONCURRENT_ACTIVITIES=5
+ATLAN_APP_DASHBOARD_HOST=localhost
+ATLAN_APP_DASHBOARD_PORT=3000
+ATLAN_APP_HTTP_HOST=0.0.0.0
+ATLAN_APP_HTTP_PORT=8000
+ATLAN_WORKFLOW_METRICS_PORT=8234
+ATLAN_SQL_SERVER_MIN_VERSION=1.0
+ENABLE_OTLP_LOGS=false
+ATLAN_HEARTBEAT_TIMEOUT_SECONDS=120 # 2 minutes
+ATLAN_START_TO_CLOSE_TIMEOUT_SECONDS=7200 # 2 hours
+# ATLAN_ENABLE_OBSERVABILITY_DAPR_SINK="false"
+
+
+# if you plan to deploy the app in customer environment, below is a sample environment variables you need to set
+ATLAN_WORKFLOW_HOST="tenant-temporal.atlan.com"
+ATLAN_WORKFLOW_PORT="443"
+ATLAN_LOCAL_DEVELOPMENT=false
+ATLAN_WORKFLOW_AUTH_ENABLED="true"
+ENABLE_ATLAN_UPLOAD="true"
+ATLAN_DEPLOYMENT_SECRETS='{"appName_app_client_id":"enter_client_id","appName_app_client_secret":"enter_secret","atlan_auth_url":"https://tenant.atlan.com/auth/realms/default/protocol/openid-connect/token","workflow_tls_enabled":"true","deployment_name":"agent-v2"}'
+
+# Storage:
+DEPLOYMENT_OBJECT_STORE_NAME="objectstore"
+UPSTREAM_OBJECT_STORE_NAME="atlan-storage"
+
+# Secret Store
+SECRET_STORE_NAME="aws-secrets"

atlan_application_sdk-0.1.1rc26/.github/release_notes.md

@@ -0,0 +1,11 @@
+## v0.1.1rc26 (August 07, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc25...v0.1.1rc26
+
+### Features
+
+- add cursor and bugbot rules (#636) (by @Amit Prabhu in [cbbecd9](https://github.com/atlanhq/application-sdk/commit/cbbecd9))
+
+### Bug Fixes
+
+- handle str and dict types in preflight checks (#638) (by @Nishchith Shetty in [57ee9a0](https://github.com/atlanhq/application-sdk/commit/57ee9a0))

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc26}/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Changelog
 
 
+## v0.1.1rc26 (August 07, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc25...v0.1.1rc26
+
+### Features
+
+- add cursor and bugbot rules (#636) (by @Amit Prabhu in [cbbecd9](https://github.com/atlanhq/application-sdk/commit/cbbecd9))
+
+### Bug Fixes
+
+- handle str and dict types in preflight checks (#638) (by @Nishchith Shetty in [57ee9a0](https://github.com/atlanhq/application-sdk/commit/57ee9a0))
+
+## v0.1.1rc25 (August 05, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc24...v0.1.1rc25
+
+### Features
+
+- implement OAuth2 authentication and data transfer for applications (#634) (by @nishantmunjal7 in [e5e70a2](https://github.com/atlanhq/application-sdk/commit/e5e70a2))
+
+
+
 ## v0.1.1rc24 (August 01, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc23...v0.1.1rc24

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc24
+Version: 0.1.1rc26
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: duckdb-engine>=0.17.0
 Requires-Dist: duckdb>=1.1.3
 Requires-Dist: fastapi[standard]>=0.115.0