fastmssql 0.2.6__cp38-cp38-macosx_11_0_arm64.whl → 0.3.2__cp38-cp38-macosx_11_0_arm64.whl

fastmssql-0.2.6.dist-info/METADATA

@@ -1,791 +0,0 @@
-Metadata-Version: 2.4
-Name: fastmssql
-Version: 0.2.6
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Rust
-Classifier: Topic :: Database
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: pytest>=7.0 ; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21 ; extra == 'dev'
-Requires-Dist: psutil>=5.9.0 ; extra == 'dev'
-Provides-Extra: dev
-License-File: LICENSE
-Summary: A high-performance Python library for Microsoft SQL Server using Rust and Tiberius
-Author-email: Riveranda <riverb514@gmail.com>
-License: PolyForm Noncommercial License 1.0.0
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Homepage, https://github.com/Rivendael/pymssql-rs
-
-
-# Fastmssql ⚡
-
-A Python library for Microsoft SQL Server built with Rust using the [Tiberius](https://github.com/prisma/tiberius) driver, [PyO3](https://github.com/PyO3/pyo3), and [bb8](https://github.com/djc/bb8) connection pooling.
-
-[![Language](https://img.shields.io/badge/Language-Rust_Backend-red)](https://github.com/Rivendael/pymssql-rs)
-[![Async](https://img.shields.io/badge/Async-Native_Tokio-blue)](https://github.com/Rivendael/pymssql-rs)
-
-## Features
-
-- **Rust-Powered Backend**: Built with Rust for memory safety and reliability
-- **No ODBC Required**: Direct native SQL Server connection without ODBC drivers
-- **Connection Pooling**: bb8-based connection pool for efficient resource management
-- **Async-Only Design**: Built on Tokio with clean async/await API
-- **Context Managers**: Automatic resource management with `async with`
-- **Type Safety**: Strong typing with automatic Python type conversion
-- **Thread Safety**: Support for concurrent operations
-- **Cross-Platform**: Works on Windows, macOS, and Linux
-- **Simple API**: Clean, intuitive async-only interface
-
-## Features
-
-Fastmssql provides reliable database connectivity with modern Python patterns:
-
-- **Production Ready**: Stable API with comprehensive error handling
-- **Connection Pooling**: Efficient resource management with configurable pools
-- **Type Conversion**: Automatic conversion between SQL Server and Python types
-- **SSL/TLS Support**: Secure connections with flexible encryption options
-
-## Installation
-
-### From PyPI (Recommended)
-
-Install fastmssql using pip:
-
-```bash
-pip install fastmssql
-```
-
-### Prerequisites
-
-- Python 3.8 to 3.13
-- Microsoft SQL Server (any recent version)
-
-### From Source (Development)
-Ensure you have Docker, Rust, and Python installed.
-If you want to build from source or contribute to development:
-
-1. Clone the repository:
-```bash
-git clone <your-repo-url>
-cd mssql-python-rust
-```
-
-2. Run the setup script
-```
-./setup.sh
-```
-
-## Quick Start
-
-> **💡 Performance Tip**: Always reuse `Connection` objects! Each `Connection` manages a connection pool, so creating multiple `Connection` instances defeats the purpose of pooling and hurts performance. Create one `Connection` per database and reuse it throughout your application.
-
-### Basic Async Usage (Recommended)
-
-```python
-import asyncio
-from fastmssql import Connection
-
-async def main():
-    # Connect to SQL Server using async context manager
-    connection_string = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
-    
-    # Automatic connection pool management
-    async with Connection(connection_string) as conn:
-        rows = await conn.execute("SELECT @@VERSION as version")
-        for row in rows:
-            print(row['version'])
-        
-        # Pool statistics
-        stats = conn.pool_stats()
-        print(f"Pool: {stats['active_connections']}/{stats['connections']} connections active")
-
-asyncio.run(main())
-```
-
-### Connection Methods
-
-The library supports two ways to connect to SQL Server:
-
-#### 1. Connection String (Traditional)
-
-```python
-import asyncio
-from fastmssql import Connection
-
-async def main():
-    # Traditional connection string approach
-    connection_string = "Server=localhost;Database=master;User Id=myuser;Password=mypass"
-    
-    async with Connection(connection_string=connection_string) as conn:
-        result = await conn.execute("SELECT @@VERSION as version")
-        for row in result.rows():
-            print(row['version'])
-
-asyncio.run(main())
-```
-
-#### 2. Individual Parameters
-
-```python
-import asyncio
-from fastmssql import Connection
-
-async def main():
-    # Using individual connection parameters
-    
-    # SQL Server Authentication  
-    async with Connection(
-        server="localhost",
-        database="master",
-        username="myuser",
-        password="mypassword"
-    ) as conn:
-        result = await conn.execute("SELECT SUSER_NAME() as login")
-        for row in result.rows():
-            print(f"Logged in as: {row['login']}")
-
-asyncio.run(main())
-```
-
-### Connection Pool Configuration
-
-Configure the connection pool for your specific needs:
-
-```python
-import asyncio
-from fastmssql import Connection, PoolConfig
-
-async def main():
-    # Custom pool configuration
-    pool_config = PoolConfig(
-        max_size=20,              # Maximum connections in pool
-        min_idle=5,               # Minimum idle connections
-        max_lifetime_secs=3600,   # Connection max lifetime (1 hour)
-        idle_timeout_secs=600,    # Idle connection timeout (10 min)
-        connection_timeout_secs=30 # Max wait time for connection
-    )
-
-    async with Connection(connection_string, pool_config) as conn:
-        result = await conn.execute("SELECT * FROM users")
-        
-    # Predefined configurations for common scenarios
-    high_throughput_config = PoolConfig.high_throughput()  # 20 connections, optimized for load
-    low_resource_config = PoolConfig.low_resource()        # 3 connections, minimal resources  
-    dev_config = PoolConfig.development()                  # 5 connections, shorter timeouts
-
-asyncio.run(main())
-```
-
-### Connection Pool Configuration
-
-For high-throughput applications, you can configure the connection pool:
-
-```python
-import asyncio
-from fastmssql import Connection, PoolConfig
-
-async def main():
-    # High-throughput pool setup
-    config = PoolConfig.high_throughput()  # Optimized for concurrent access
-    
-    async with Connection(connection_string, config) as conn:
-        # Pool configured for concurrent operations
-        
-        # Concurrent workers for high throughput
-        async def worker():
-            result = await conn.execute("SELECT @@VERSION")
-            return result.rows()
-        
-        # Run multiple concurrent workers
-        tasks = [worker() for _ in range(20)]
-        results = await asyncio.gather(*tasks)
-        
-        # Pool monitoring
-        stats = await conn.pool_stats()
-        print(f"Pool utilization: {stats['active_connections']}/{stats['max_size']}")
-
-asyncio.run(main())
-```
-
-**Performance Tips:**
-- **Reuse Connection objects**: Create one `Connection` per database and reuse it across your application
-- Use `PoolConfig.high_throughput()` for high-throughput applications
-- Leverage `asyncio.gather()` for concurrent operations  
-- Monitor pool stats to optimize connection count
-- Consider connection lifetime for long-running applications
-
-**⚠️ Performance Anti-Pattern:**
-```python
-# DON'T DO THIS - Creates new pool for each operation
-async def bad_example():
-    async with Connection(conn_str) as conn:  # New pool created
-        return await conn.execute("SELECT 1")
-    
-    async with Connection(conn_str) as conn:  # Another new pool created
-        return await conn.execute("SELECT 2")
-```
-
-**✅ Correct Pattern:**
-```python
-# DO THIS - Reuse the same connection pool
-async def good_example():
-    async with Connection(conn_str) as conn:  # Single pool created
-        result1 = await conn.execute("SELECT 1")
-        result2 = await conn.execute("SELECT 2")  # Reuses same pool
-        return result1, result2
-```
-
-### Connection Pool Benefits
-
-The bb8 connection pool provides significant performance improvements over traditional Python libraries:
-
-| Metric | Traditional Python | fastmssql | Improvement |
-|--------|-------------------|-----------|-------------|
-| **Connection Setup** | 50ms | 0.1ms | **500x faster** |
-| **Memory per Query** | 50-200 KB | 0.5 KB | **100-400x less** |
-| **10 Concurrent Queries** | 500ms | 150ms | **3.3x faster** |
-| **100 Concurrent Queries** | 5000ms | 400ms | **12.5x faster** |
-| **1000 Concurrent Queries** | Timeouts/Errors | 2.9s | **Stable** |
-| **Memory Leaks** | Common | None | **Zero leaks** |
-
-**Key Benefits:**
-- **Connection Reuse**: Eliminates connection establishment overhead (500x improvement)
-- **Memory Efficiency**: Uses 100-400x less memory per operation (0.5 KB vs 50-200 KB)
-- **Zero Memory Leaks**: Automatic cleanup with decreasing memory usage over time
-- **Concurrency**: Safe multi-threaded access with automatic pooling
-- **Resource Management**: Intelligent memory and connection lifecycle management
-- **Load Balancing**: Intelligent connection distribution across threads
-- **Fault Tolerance**: Built-in retry logic and connection health checks
-- **Timeouts**: Configurable timeouts prevent hanging connections
-
-### Connection Strings
-
-The library supports standard SQL Server connection string formats:
-
-```python
-# SQL Server Authentication
-conn_str = "Server=localhost;Database=MyDB;User Id=sa;Password=MyPassword"
-
-# With specific port
-conn_str = "Server=localhost,1433;Database=MyDB;User Id=myuser;Password=mypass"
-
-# Azure SQL Database
-conn_str = "Server=tcp:myserver.database.windows.net,1433;Database=MyDB;User Id=myuser;Password=mypass;Encrypt=true"
-```
-
-### Working with Data
-
-```python
-import asyncio
-from fastmssql import Connection
-
-async def main():
-    async with Connection(connection_string) as conn:
-        # Execute queries
-        users = await conn.execute("SELECT id, name, email FROM users WHERE active = 1")
-        
-        # Iterate through results
-        for user in users:
-            print(f"User {user['id']}: {user['name']} ({user['email']})")
-        
-        # Execute non-query operations
-        rows_affected = await conn.execute_non_query(
-            "UPDATE users SET last_login = GETDATE() WHERE id = 123"
-        )
-        print(f"Updated {rows_affected} rows")
-        
-        # Work with different data types
-        data = await conn.execute("""
-            SELECT 
-                42 as int_value,
-                3.14159 as float_value,
-                'Hello World' as string_value,
-                GETDATE() as datetime_value,
-                CAST(1 as BIT) as bool_value,
-                NULL as null_value
-        """)
-        
-        row = data[0]
-        for column_name, value in row.items():
-            print(f"{column_name}: {value} (type: {type(value).__name__})")
-
-asyncio.run(main())
-```
-
-## Usage
-
-### Asynchronous Usage with Connection Pooling
-
-Full async/await support with automatic connection pool management:
-
-```python
-import asyncio
-from fastmssql import Connection
-
-async def main():
-    connection_string = "Server=localhost;Database=test;Integrated Security=true"
-    
-    # Async context manager with automatic pool management
-    async with Connection(connection_string) as conn:
-        rows = await conn.execute("SELECT name FROM sys.databases")
-        for row in rows:
-            print(row['name'])
-            
-        # Pool statistics
-        stats = conn.pool_stats()
-        print(f"Pool: {stats['active_connections']}/{stats['connections']} connections active")
-    
-    # High-performance concurrent operations
-    async def fetch_user_data(user_id):
-        async with Connection(connection_string) as conn:
-            return await conn.execute(f"SELECT * FROM users WHERE id = {user_id}")
-    
-    # Execute multiple queries concurrently using the connection pool
-    user_ids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    tasks = [fetch_user_data(uid) for uid in user_ids]
-    results = await asyncio.gather(*tasks)  # bb8 pool handles concurrent connections efficiently
-    
-    for user_data in results:
-        if user_data:
-            print(f"User: {user_data[0]['name']}")
-
-asyncio.run(main())
-```
-
-### Performance Comparison: bb8 Connection Pool
-
-The bb8 connection pool dramatically improves performance, especially under load:
-
-```python
-import asyncio
-import time
-from fastmssql import Connection
-
-async def performance_comparison():
-    connection_string = "Server=localhost;Database=test;User Id=myuser;Password=mypass"
-    
-    # Sequential async operations (still efficient with pool reuse)
-    start = time.time()
-    async with Connection(connection_string) as conn:
-        for i in range(10):
-            result = await conn.execute("SELECT COUNT(*) FROM users")
-    sequential_time = time.time() - start
-
-    # Concurrent async operations (much faster with bb8 pool)
-    start = time.time()
-    async def concurrent_queries():
-        tasks = []
-        for i in range(10):
-            async def query():
-                async with Connection(connection_string) as conn:  # Pool reuse
-                    return await conn.execute("SELECT COUNT(*) FROM users")
-            tasks.append(query())
-        return await asyncio.gather(*tasks)
-    
-    await concurrent_queries()
-    concurrent_time = time.time() - start
-    
-    print(f"Sequential: {sequential_time:.3f}s")
-    print(f"Concurrent: {concurrent_time:.3f}s") 
-    print(f"Improvement: {sequential_time/concurrent_time:.1f}x faster")
-
-asyncio.run(performance_comparison())
-```
-
-**Real-world Performance Benefits:**
-- **Web Applications**: Handle 100+ concurrent requests without connection exhaustion
-- **Batch Processing**: Process large datasets with optimal resource usage
-- **Microservices**: Reliable database connections across service boundaries
-- **Data Analytics**: Concurrent query execution for faster insights
-
-## Examples
-
-Run the provided examples to see async patterns and features:
-
-```bash
-# Basic asynchronous usage
-python examples/basic_usage.py
-
-# Advanced asynchronous features  
-python examples/advanced_usage.py
-
-# Asynchronous usage patterns
-python examples/async_usage.py
-
-# Advanced pool configuration
-python examples/advanced_pool_config.py
-
-# Connection parameters demonstration
-python examples/connection_parameters_demo.py
-```
-
-### Key API Improvements
-
-Our async-only design provides a clean, intuitive interface:
-
-```python
-# ✅ Clean async API (New Design)
-async with Connection(connection_string) as conn:
-    result = await conn.execute(sql)           # Intuitive!
-    rows_affected = await conn.execute_non_query(sql)
-
-# ❌ Old confusing API (Removed)
-# async with Connection(connection_string) as conn:
-#     result = await conn.execute_async(sql)   # Confusing suffixes
-#     rows_affected = await conn.execute_non_query_async(sql)
-```
-
-## Development
-
-### Building from Source
-
-```bash
-# Install development dependencies
-pip install maturin pytest pytest-asyncio black ruff
-
-# Build in development mode
-maturin develop
-
-# Run tests
-python -m pytest tests/
-
-# Format code
-black python/
-ruff check python/
-```
-
-### Project Structure
-
-```
-mssql-python-rust/
-├── src/                    # Rust source code
-│   ├── lib.rs             # Main library entry point
-│   ├── connection.rs      # Connection handling
-│   ├── query.rs           # Query execution
-│   └── types.rs           # Type definitions
-├── python/                # Python source code
-│   ├── __init__.py        # Main Python module
-│   ├── mssql.py          # High-level API
-│   └── types.py          # Python type definitions
-├── examples/              # Usage examples
-├── tests/                 # Test files
-├── Cargo.toml            # Rust dependencies
-├── pyproject.toml        # Python project configuration
-└── README.md             # This file
-```
-
-### Testing
-
-Run the examples to test your installation:
-
-```bash
-# Basic functionality
-python examples/basic_usage.py
-
-# Advanced features
-python examples/advanced_usage.py
-```
-
-## API Reference
-
-### Core Classes
-
-#### `Connection`
-Main connection class with bb8 connection pool management.
-
-**Constructor:**
-```python
-Connection(connection_string: str, pool_config: Optional[PoolConfig] = None)
-```
-
-**Context Manager Support:**
-```python
-# Synchronous
-with Connection(conn_str) as conn:
-    result = conn.execute("SELECT * FROM table")
-
-# Asynchronous  
-async with Connection(conn_str) as conn:
-    result = await conn.execute_async("SELECT * FROM table")
-```
-
-**Methods:**
-- `execute(sql: str) -> List[Row]` - Execute a query synchronously
-- `pool_stats() -> dict` - Get connection pool statistics
-- `disconnect()` - Close the connection pool
-- `is_connected() -> bool` - Check if pool is active
-
-**Pool Statistics:**
-```python
-stats = conn.pool_stats()
-# Returns: {
-#     'connections': 10,        # Total connections in pool
-#     'active_connections': 3,  # Currently active connections  
-#     'idle_connections': 7     # Available idle connections
-# }
-```
-
-#### `PoolConfig` 
-Configuration class for bb8 connection pool settings.
-
-**Constructor:**
-```python
-PoolConfig(
-    max_size: int = 10,                    # Maximum connections in pool
-    min_idle: int = 0,                     # Minimum idle connections
-    max_lifetime_secs: Optional[int] = None,  # Connection max lifetime
-    idle_timeout_secs: Optional[int] = None,  # Idle connection timeout
-    connection_timeout_secs: int = 30         # Max wait time for connection
-)
-```
-
-**Predefined Configurations:**
-```python
-# High throughput applications (web servers, APIs)
-config = PoolConfig.high_throughput()    # 20 connections, optimized settings
-
-# Low resource environments (embedded, containers)  
-config = PoolConfig.low_resource()       # 3 connections, minimal overhead
-
-# Development environments
-config = PoolConfig.development()        # 5 connections, shorter timeouts
-```
-
-#### `Row`
-Represents a database row with column access.
-
-**Methods:**
-- `get(column: str) -> Value` - Get value by column name
-- `get_by_index(index: int) -> Value` - Get value by column index  
-- `columns() -> List[str]` - Get column names
-- `values() -> List[Value]` - Get all values
-- `to_dict() -> dict` - Convert to dictionary
-
-### Module Functions
-
-#### Connection Management
-```python
-# Create connection with default pool settings
-connect(connection_string: str) -> Connection
-
-# Create async connection with default pool settings
-connect_async(connection_string: str) -> Connection
-
-# One-liner query execution
-execute(connection_string: str, sql: str) -> List[dict]
-execute_async(connection_string: str, sql: str) -> List[dict]
-```
-
-#### Utility Functions
-```python
-version() -> str  # Get library version
-```
-
-### Connection Pool Architecture
-
-The library uses the bb8 connection pool for efficient resource management:
-
-1. **Pool Initialization**: Creates a pool of reusable connections on first use
-2. **Connection Reuse**: Automatically reuses idle connections for new requests
-3. **Load Balancing**: Distributes connections across concurrent operations
-4. **Automatic Cleanup**: Closes idle connections based on timeout settings
-5. **Thread Safety**: Safe for use across multiple threads and async tasks
-
-### Error Handling
-
-```python
-try:
-    async with mssql.connect_async(connection_string) as conn:
-        result = await conn.execute("SELECT * FROM invalid_table")
-except Exception as e:
-    print(f"Database error: {e}")
-    # Connection automatically returned to pool even on error
-```
-
-## Migration to Async-Only Architecture
-
-This library has been upgraded to use async-only operations with the bb8 connection pool for improved performance and reliability.
-
-**Async-Only API:**
-```python  
-# Async-only with automatic connection pooling
-async with mssql.connect_async(conn_str) as conn:
-    result = await conn.execute("SELECT * FROM table")
-    
-    # Pool statistics
-    stats = conn.pool_stats()
-    print(f"Pool utilization: {stats['active_connections']}/{stats['connections']}")
-```
-
-**Features:**
-- Async-only operations for optimal concurrency
-- Automatic connection pooling with bb8
-- Configurable pool settings via `PoolConfig`
-- Pool statistics and monitoring
-- Improved concurrent performance
-- Better resource management
-
-**Breaking Changes:**
-- None - the API is fully backward compatible
-- All existing code continues to work without modification
-- Performance improvements are automatic
-
-## Advanced Usage Patterns
-
-### Custom Pool Configuration for Different Scenarios
-
-```python
-from fastmssql import Connection, PoolConfig
-
-# High-load web application
-web_config = PoolConfig(
-    max_size=50,               # Handle many concurrent requests
-    min_idle=10,               # Keep connections ready
-    max_lifetime_secs=1800,    # 30 min connection lifetime
-    idle_timeout_secs=300,     # 5 min idle timeout
-    connection_timeout_secs=10 # Fast timeout for web responses
-)
-
-# Batch processing application  
-batch_config = PoolConfig(
-    max_size=5,                # Fewer connections
-    min_idle=2,                # Always keep some ready
-    max_lifetime_secs=7200,    # 2 hour lifetime for long operations
-    idle_timeout_secs=1800,    # 30 min idle timeout
-    connection_timeout_secs=60 # Longer timeout for batch work
-)
-
-# Microservice with limited resources
-micro_config = PoolConfig(
-    max_size=3,                # Minimal connections
-    min_idle=1,                # One always ready
-    max_lifetime_secs=3600,    # 1 hour lifetime
-    idle_timeout_secs=600,     # 10 min idle timeout
-    connection_timeout_secs=15 # Quick timeout
-)
-```
-
-### Monitoring Pool Health
-
-```python
-async def monitor_database_pool():
-    """Monitor connection pool health and performance"""
-    
-    async with mssql.connect_async(connection_string) as conn:
-        while True:
-            stats = conn.pool_stats()
-            utilization = stats['active_connections'] / stats['connections'] * 100
-            
-            print(f"Pool Utilization: {utilization:.1f}%")
-            print(f"Active: {stats['active_connections']}, Idle: {stats['idle_connections']}")
-            
-            # Alert if pool utilization is too high
-            if utilization > 90:
-                print("WARNING: High pool utilization detected!")
-                
-            await asyncio.sleep(30)  # Check every 30 seconds
-```
-
-### Optimizing for Different Database Workloads
-
-```python
-# OLTP (Online Transaction Processing) - Many small, fast queries
-oltp_config = PoolConfig.high_throughput()
-async def oltp_operations():
-    async with mssql.connect_async(conn_str, oltp_config) as conn:
-        # Fast, concurrent transactions
-        tasks = [
-            conn.execute_async("SELECT * FROM users WHERE id = $1", [user_id])
-            for user_id in range(1, 101)
-        ]
-        results = await asyncio.gather(*tasks)
-
-# OLAP (Online Analytical Processing) - Fewer, longer-running queries  
-olap_config = PoolConfig.low_resource()
-async def olap_operations():
-    async with mssql.connect_async(conn_str, olap_config) as conn:
-        # Long-running analytical queries
-        quarterly_report = await conn.execute_async("""
-            SELECT 
-                DATE_TRUNC('quarter', order_date) as quarter,
-                SUM(total_amount) as total_revenue,
-                COUNT(*) as order_count
-            FROM orders 
-            WHERE order_date >= '2024-01-01'
-            GROUP BY DATE_TRUNC('quarter', order_date)
-            ORDER BY quarter
-        """)
-        return quarterly_report
-```
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Import Error**: Make sure you've built the extension with `maturin develop`
-2. **Connection Fails**: Check your connection string and SQL Server configuration. Note that Windows authentication is not supported - use SQL Server authentication with username and password.
-3. **Build Errors**: Ensure you have the Rust toolchain installed
-4. **Build Issues**: Make sure you have the Microsoft Visual C++ Build Tools on Windows
-
-
-## Contributing
-
-Contributions are welcome! Please open an issue or submit a pull request for any enhancements or bug fixes.
-
-
-## License
-
-This project is licensed under the PolyForm Noncommercial License 1.0.0. See the LICENSE file for details.
-
-## Third-Party Attributions
-
-This project includes and depends on third-party libraries licensed under the Apache License 2.0 and MIT License, as well as other open source licenses.
-
-**Note:** Additional third-party libraries and their license information are listed in `licenses/NOTICE.txt`.
-
-- [Tiberius](https://github.com/prisma/tiberius) (Apache License 2.0)
-- [PyO3](https://github.com/PyO3/pyo3) (Apache License 2.0)
-- [pyo3-asyncio](https://github.com/PyO3/pyo3-asyncio) (Apache License 2.0)
-- [bb8](https://github.com/djc/bb8) (MIT or Apache License 2.0)
-- [bb8-tiberius](https://github.com/prisma/tiberius) (Apache License 2.0)
-- [tokio](https://github.com/tokio-rs/tokio) (MIT or Apache License 2.0)
-- [tokio-util](https://github.com/tokio-rs/tokio) (MIT or Apache License 2.0)
-- [futures](https://github.com/rust-lang/futures-rs) (MIT or Apache License 2.0)
-- [serde](https://github.com/serde-rs/serde) (MIT or Apache License 2.0)
-- [serde_json](https://github.com/serde-rs/json) (MIT or Apache License 2.0)
-- [anyhow](https://github.com/dtolnay/anyhow) (MIT or Apache License 2.0)
-- [chrono](https://github.com/chronotope/chrono) (MIT or Apache License 2.0)
-- [uuid](https://github.com/uuid-rs/uuid) (MIT or Apache License 2.0)
-- [tempfile](https://github.com/Stebalien/tempfile) (MIT or Apache License 2.0)
-- [pytest](https://github.com/pytest-dev/pytest) (MIT License)
-- [pytest-asyncio](https://github.com/pytest-dev/pytest-asyncio) (MIT License)
-- [black](https://github.com/psf/black) (MIT License)
-- [ruff](https://github.com/astral-sh/ruff) (MIT License)
-- [maturin](https://github.com/PyO3/maturin) (Apache License 2.0 or MIT License)
-- [Python](https://www.python.org/) and [asyncio](https://docs.python.org/3/library/asyncio.html) (Python Software Foundation License)
-
-See the `licenses/NOTICE.txt` file for full attribution and copyright information.
-The full text of the Apache License 2.0 is provided in the `licenses/APACHE_LICENSE_2.0.txt` file.
-The full text of the MIT License is provided in the `licenses/MIT_LICENSE.txt` file.
-
-## Acknowledgments
-
-- [Tiberius](https://github.com/prisma/tiberius) - Rust SQL Server driver (Apache License 2.0)
-- [PyO3](https://github.com/PyO3/pyo3) - Python bindings for Rust (Apache License 2.0)
-- [pyo3-asyncio](https://github.com/PyO3/pyo3-asyncio) - Async bridge for PyO3 (Apache License 2.0)
-- [pytest](https://github.com/pytest-dev/pytest) - Python testing framework (MIT License)
-- [pytest-asyncio](https://github.com/pytest-dev/pytest-asyncio) - Async test support for pytest (MIT License)
-- [black](https://github.com/psf/black) - Python code formatter (MIT License)
-- [ruff](https://github.com/astral-sh/ruff) - Python linter (MIT License)
-- [Python](https://www.python.org/) and [asyncio](https://docs.python.org/3/library/asyncio.html) - Python standard library (Python Software Foundation License)
-- [Maturin](https://github.com/PyO3/maturin) - Build tool for Python extensions in Rust