esuls 0.1.0__py3-none-any.whl

esuls/__init__.py

@@ -0,0 +1,21 @@
+"""
+esuls - Utility library for async database operations, HTTP requests, and parallel execution
+"""
+
+__version__ = "0.1.0"
+
+# Import all utilities
+from .utils import run_parallel
+from .db_cli import AsyncDB, BaseModel
+from .request_cli import AsyncRequest, make_request, make_request_cffi, Response
+
+__all__ = [
+    '__version__',
+    'run_parallel',
+    'AsyncDB',
+    'BaseModel',
+    'AsyncRequest',
+    'make_request',
+    'make_request_cffi',
+    'Response',
+]

esuls/db_cli.py

@@ -0,0 +1,439 @@
+import asyncio
+import aiosqlite
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, TypeVar, Generic, Type, get_type_hints, Union, Tuple
+from dataclasses import dataclass, asdict, fields, is_dataclass, field
+from functools import lru_cache
+import uuid
+import contextlib
+import enum
+
+T = TypeVar('T')
+SchemaType = TypeVar('SchemaType', bound='BaseModel')
+
+@dataclass
+class BaseModel:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()), metadata={"primary_key": True})
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+
+class AsyncDB(Generic[SchemaType]):
+    """High-performance async SQLite with dataclass schema and reliable connection handling."""
+    
+    OPERATOR_MAP = {
+        'gt': '>', 'lt': '<', 'gte': '>=', 'lte': '<=', 
+        'neq': '!=', 'like': 'LIKE', 'in': 'IN', 'eq': '='
+    }
+    
+    def __init__(self, db_path: Union[str, Path], table_name: str, schema_class: Type[SchemaType]):
+        """Initialize AsyncDB with a path and schema dataclass."""
+        if not is_dataclass(schema_class):
+            raise TypeError(f"Schema must be a dataclass, got {schema_class}")
+            
+        self.db_path = Path(db_path).resolve()
+        self.schema_class = schema_class
+        self.table_name = table_name
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Make schema initialization unique per instance
+        self._db_key = f"{str(self.db_path)}:{self.table_name}:{self.schema_class.__name__}"
+        self._write_lock = asyncio.Lock()
+        self._type_hints = get_type_hints(schema_class)
+        
+        # Use a class-level set to track initialized schemas
+        if not hasattr(AsyncDB, '_initialized_schemas'):
+            AsyncDB._initialized_schemas = set()
+    
+    async def _get_connection(self) -> aiosqlite.Connection:
+        """Create a new optimized connection."""
+        db = await aiosqlite.connect(self.db_path)
+        # Fast WAL mode with minimal sync
+        await db.execute("PRAGMA journal_mode=WAL")
+        await db.execute("PRAGMA synchronous=NORMAL")
+        await db.execute("PRAGMA cache_size=10000")
+        
+        # Initialize schema if needed (check per unique schema)
+        if self._db_key not in AsyncDB._initialized_schemas:
+            await self._init_schema(db)
+            AsyncDB._initialized_schemas.add(self._db_key)
+            
+        return db
+    
+    async def _init_schema(self, db: aiosqlite.Connection) -> None:
+        """Generate schema from dataclass structure with support for field additions."""
+        print(f"Initializing schema for {self.schema_class.__name__} in table {self.table_name}")
+        
+        field_defs = []
+        indexes = []
+        
+        # First check if table exists
+        cursor = await db.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            (self.table_name,)
+        )
+        table_exists = await cursor.fetchone() is not None
+        
+        existing_columns = set()
+        if table_exists:
+            # Get existing columns if table exists
+            cursor = await db.execute(f"PRAGMA table_info({self.table_name})")
+            columns = await cursor.fetchall()
+            existing_columns = {col[1] for col in columns}  # col[1] is the column name
+        
+        # Process all fields in the dataclass - ONLY THIS SCHEMA CLASS
+        schema_fields = fields(self.schema_class)
+        print(f"Processing {len(schema_fields)} fields for {self.schema_class.__name__}")
+        
+        for f in schema_fields:
+            field_name = f.name
+            field_type = self._type_hints.get(field_name)
+            print(f"  Field: {field_name} -> {field_type}")
+            
+            # Map Python types to SQLite types
+            if field_type in (int, bool):
+                sql_type = "INTEGER"
+            elif field_type in (float,):
+                sql_type = "REAL"
+            elif field_type in (str, enum.EnumType):
+                sql_type = "TEXT"
+            elif field_type in (datetime,):
+                sql_type = "TIMESTAMP"
+            elif field_type == List[str]:
+                sql_type = "TEXT"  # Stored as JSON
+            else:
+                sql_type = "TEXT"  # Default to TEXT/JSON for complex types
+                
+            # Handle special field metadata
+            constraints = []
+            if f.metadata.get('primary_key'):
+                constraints.append("PRIMARY KEY")
+            if f.metadata.get('unique'):
+                constraints.append("UNIQUE")
+            if not f.default and not f.default_factory and f.metadata.get('required', True):
+                constraints.append("NOT NULL")
+                
+            field_def = f"{field_name} {sql_type} {' '.join(constraints)}"
+            
+            if not table_exists:
+                # Add field definition for new table creation
+                field_defs.append(field_def)
+            elif field_name not in existing_columns:
+                # Alter table to add the new column without NOT NULL constraint
+                alter_sql = f"ALTER TABLE {self.table_name} ADD COLUMN {field_name} {sql_type}"
+                print(f"  Adding new column: {alter_sql}")
+                await db.execute(alter_sql)
+                await db.commit()
+                
+            # Handle indexes
+            if f.metadata.get('index'):
+                index_name = f"idx_{self.table_name}_{field_name}"
+                index_sql = f"CREATE INDEX IF NOT EXISTS {index_name} ON {self.table_name}({field_name})"
+                indexes.append(index_sql)
+        
+        # Create table if it doesn't exist
+        if not table_exists:
+            # Check for table constraints
+            table_constraints = getattr(self.schema_class, '__table_constraints__', [])
+
+            constraints_sql = ""
+            if table_constraints:
+                constraints_sql = ", " + ", ".join(table_constraints)
+
+            create_sql = f"""
+                CREATE TABLE IF NOT EXISTS {self.table_name} (
+                    {', '.join(field_defs)}{constraints_sql}
+                )
+            """
+            print(f"Creating table: {create_sql}")
+            await db.execute(create_sql)
+        
+        # Create indexes
+        for idx_stmt in indexes:
+            await db.execute(idx_stmt)
+            
+        await db.commit()
+        print(f"Schema initialization complete for {self.schema_class.__name__}")
+    
+    @contextlib.asynccontextmanager
+    async def transaction(self):
+        """Run operations in a transaction with reliable cleanup."""
+        db = await self._get_connection()
+        try:
+            yield db
+            await db.commit()
+        except Exception:
+            await db.rollback()
+            raise
+        finally:
+            await db.close()
+    
+    # @lru_cache(maxsize=128)
+    def _serialize_value(self, value: Any) -> Any:
+        """Fast value serialization with type-based optimization."""
+        if value is None or isinstance(value, (int, float, bool, str)):
+            return value
+        if isinstance(value, datetime):
+            return value.isoformat()
+        if isinstance(value, enum.Enum):
+            return value.value
+        if isinstance(value, (list, dict, tuple)):
+            return json.dumps(value)
+        return str(value)
+    
+    def _deserialize_value(self, field_name: str, value: Any) -> Any:
+        """Deserialize values based on field type."""
+        if value is None:
+            return value
+
+        field_type = self._type_hints.get(field_name)
+
+        # Handle string fields - ensure phone numbers are strings
+        if field_type is str or (hasattr(field_type, '__origin__') and field_type.__origin__ is Union and str in getattr(field_type, '__args__', ())):
+            return str(value)
+
+        if field_type is datetime and isinstance(value, str):
+            return datetime.fromisoformat(value)
+
+        # Handle enum types
+        if hasattr(field_type, '__origin__') and field_type.__origin__ is Union:
+            # Handle Optional[EnumType] case
+            args = getattr(field_type, '__args__', ())
+            for arg in args:
+                if arg is not type(None) and hasattr(arg, '__bases__') and enum.Enum in arg.__bases__:
+                    try:
+                        return arg(value)
+                    except (ValueError, TypeError):
+                        pass
+        elif hasattr(field_type, '__bases__') and enum.Enum in field_type.__bases__:
+            # Handle direct enum types
+            try:
+                return field_type(value)
+            except (ValueError, TypeError):
+                pass
+
+        if isinstance(value, str):
+            try:
+                return json.loads(value)
+            except (json.JSONDecodeError, TypeError):
+                pass
+
+        return value
+    
+    @lru_cache(maxsize=64)
+    def _generate_save_sql(self, field_names: Tuple[str, ...]) -> str:
+        """Generate efficient SQL for upsert with proper conflict handling."""
+        columns = ','.join(field_names)
+        placeholders = ','.join('?' for _ in field_names)
+
+        return f"""
+            INSERT OR REPLACE INTO {self.table_name} ({columns},id)
+            VALUES ({placeholders},?)
+        """
+    
+    async def save_batch(self, items: List[SchemaType], skip_errors: bool = True) -> int:
+        """Save multiple items in a single transaction for better performance.
+
+        Args:
+            items: List of schema objects to save
+            skip_errors: If True, skip items that cause errors
+
+        Returns:
+            Number of items successfully saved
+        """
+        if not items:
+            return 0
+
+        saved_count = 0
+
+        async with self._write_lock:
+            async with self.transaction() as db:
+                for item in items:
+                    try:
+                        if not isinstance(item, self.schema_class):
+                            if not skip_errors:
+                                raise TypeError(f"Expected {self.schema_class.__name__}, got {type(item).__name__}")
+                            continue
+
+                        # Extract and process data
+                        data = asdict(item)
+                        item_id = data.pop('id', None) or str(uuid.uuid4())
+
+                        # Ensure created_at and updated_at are set
+                        now = datetime.now()
+                        if not data.get('created_at'):
+                            data['created_at'] = now
+                        data['updated_at'] = now
+
+                        # Prepare SQL and values
+                        field_names = tuple(sorted(data.keys()))
+                        sql = self._generate_save_sql(field_names)
+                        values = [self._serialize_value(data[name]) for name in field_names]
+                        values.append(item_id)
+
+                        # Execute save
+                        await db.execute(sql, values)
+                        saved_count += 1
+
+                    except Exception as e:
+                        if skip_errors:
+                            # Optionally log the error for debugging
+                            # print(f"Save error (skipped): {e}")
+                            continue
+                        raise
+
+        return saved_count
+
+    async def save(self, item: SchemaType, skip_errors: bool = True) -> bool:
+        """Store a schema object with upsert functionality and error handling.
+
+        Args:
+            item: The schema object to save
+            skip_errors: If True, silently skip errors and return False. If False, raise errors.
+
+        Returns:
+            True if save was successful, False if error occurred and skip_errors=True
+        """
+        try:
+            if not isinstance(item, self.schema_class):
+                if skip_errors:
+                    return False
+                raise TypeError(f"Expected {self.schema_class.__name__}, got {type(item).__name__}")
+
+            # Extract and process data
+            data = asdict(item)
+            item_id = data.pop('id', None) or str(uuid.uuid4())
+
+            # Ensure created_at and updated_at are set
+            now = datetime.now()
+            if not data.get('created_at'):
+                data['created_at'] = now
+            data['updated_at'] = now
+
+            # Prepare SQL and values
+            field_names = tuple(sorted(data.keys()))
+            sql = self._generate_save_sql(field_names)
+            values = [self._serialize_value(data[name]) for name in field_names]
+            values.append(item_id)
+
+            # Perform save with reliable transaction
+            async with self._write_lock:
+                async with self.transaction() as db:
+                    await db.execute(sql, values)
+
+            return True
+
+        except Exception as e:
+            if skip_errors:
+                # Optionally log the error for debugging
+                # print(f"Save error (skipped): {e}")
+                return False
+            raise
+    
+    async def get_by_id(self, id: str) -> Optional[SchemaType]:
+        """Fetch an item by ID with reliable connection handling."""
+        async with self.transaction() as db:
+            cursor = await db.execute(f"SELECT * FROM {self.table_name} WHERE id = ?", (id,))
+            row = await cursor.fetchone()
+            
+            if not row:
+                return None
+                
+            # Get column names and build data dictionary
+            columns = [desc[0] for desc in cursor.description]
+            return self.schema_class(**{
+                col: self._deserialize_value(col, row[i]) 
+                for i, col in enumerate(columns)
+            })
+    
+    def _build_where_clause(self, filters: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        """Build optimized WHERE clause for queries."""
+        if not filters:
+            return "", []
+            
+        conditions = []
+        values = []
+        
+        for key, value in filters.items():
+            # Handle special values
+            if value == 'now':
+                value = datetime.now()
+                
+            # Parse field and operator
+            parts = key.split('__', 1)
+            field = parts[0]
+            
+            if len(parts) > 1 and parts[1] in self.OPERATOR_MAP:
+                op_str = self.OPERATOR_MAP[parts[1]]
+                
+                # Handle IN operator specially
+                if op_str == 'IN' and isinstance(value, (list, tuple)):
+                    placeholders = ','.join(['?'] * len(value))
+                    conditions.append(f"{field} IN ({placeholders})")
+                    values.extend(value)
+                else:
+                    conditions.append(f"{field} {op_str} ?")
+                    values.append(value)
+            else:
+                # Default to equality
+                conditions.append(f"{field} = ?")
+                values.append(value)
+                
+        return f"WHERE {' AND '.join(conditions)}", values
+    
+    async def find(self, order_by=None, **filters) -> List[SchemaType]:
+        """Query items with reliable connection handling."""
+        where_clause, values = self._build_where_clause(filters)
+        
+        # Build query
+        query = f"SELECT * FROM {self.table_name} {where_clause}"
+        
+        # Add ORDER BY clause if specified
+        if order_by:
+            order_fields = [order_by] if isinstance(order_by, str) else order_by
+            order_clauses = [
+                f"{field[1:]} DESC" if field.startswith('-') else f"{field} ASC" 
+                for field in order_fields
+            ]
+            query += f" ORDER BY {', '.join(order_clauses)}"
+        
+        # Execute query with reliable transaction
+        async with self.transaction() as db:
+            cursor = await db.execute(query, values)
+            rows = await cursor.fetchall()
+            
+            if not rows:
+                return []
+                
+            # Process results
+            columns = [desc[0] for desc in cursor.description]
+            return [
+                self.schema_class(**{
+                    col: self._deserialize_value(col, row[i])
+                    for i, col in enumerate(columns)
+                })
+                for row in rows
+            ]
+    
+    async def count(self, **filters) -> int:
+        """Count items matching filters with reliable connection handling."""
+        where_clause, values = self._build_where_clause(filters)
+        query = f"SELECT COUNT(*) FROM {self.table_name} {where_clause}"
+        
+        async with self.transaction() as db:
+            cursor = await db.execute(query, values)
+            result = await cursor.fetchone()
+            return result[0] if result else 0
+    
+    async def fetch_all(self) -> List[SchemaType]:
+        """Retrieve all items."""
+        return await self.find()
+    
+    async def delete(self, id: str) -> bool:
+        """Delete an item by ID with reliable transaction handling."""
+        async with self._write_lock:
+            async with self.transaction() as db:
+                cursor = await db.execute(f"DELETE FROM {self.table_name} WHERE id = ?", (id,))
+                return cursor.rowcount > 0

esuls/request_cli.py

@@ -0,0 +1,384 @@
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TypeAlias, Union, Optional, Dict, Any, TypeVar, AsyncContextManager, Literal
+import asyncio
+import json
+import ssl
+from loguru import logger
+import httpx
+from fake_useragent import UserAgent
+from curl_cffi.requests import AsyncSession
+
+# Type definitions optimized
+ResponseT = TypeVar('ResponseT', bound='Response')
+JsonType: TypeAlias = Dict[str, Any]
+FileData: TypeAlias = tuple[str, Union[bytes, str], str]
+Headers: TypeAlias = Dict[str, str]
+HttpMethod: TypeAlias = Literal["GET", "POST",
+                                "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]
+
+# Global shared client with connection pooling to prevent "Too many open files" error
+_shared_client: Optional[httpx.AsyncClient] = None
+_client_lock = asyncio.Lock()
+
+# Global cached UserAgent to prevent file descriptor exhaustion
+_user_agent: Optional[UserAgent] = None
+_user_agent_lock = asyncio.Lock()
+
+
+async def _get_user_agent() -> str:
+    """Get or create cached UserAgent instance to avoid file descriptor leaks"""
+    global _user_agent
+    async with _user_agent_lock:
+        if _user_agent is None:
+            try:
+                _user_agent = UserAgent()
+            except Exception as e:
+                # Fallback to a static user agent if UserAgent() fails
+                logger.warning(
+                    f"Failed to initialize UserAgent, using fallback: {e}")
+                return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+
+        try:
+            return _user_agent.random
+        except Exception as e:
+            logger.warning(
+                f"Failed to get random user agent, using fallback: {e}")
+            return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+
+
+@lru_cache(maxsize=1)
+def _create_optimized_ssl_context() -> ssl.SSLContext:
+    """Create an SSL context optimized for performance"""
+    ctx = ssl._create_default_https_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    ctx.set_alpn_protocols(['http/1.1'])
+    ctx.post_handshake_auth = True
+    return ctx
+
+
+async def _get_shared_client() -> httpx.AsyncClient:
+    """Get or create shared HTTP client with connection pooling"""
+    global _shared_client
+    async with _client_lock:
+        if _shared_client is None or _shared_client.is_closed:
+            _shared_client = httpx.AsyncClient(
+                verify=_create_optimized_ssl_context(),
+                timeout=60,
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_connections=100,
+                    max_keepalive_connections=50,
+                    keepalive_expiry=30.0
+                )
+            )
+        return _shared_client
+
+
+@dataclass(frozen=True)
+class Response:
+    """Immutable response object with strong typing"""
+    status_code: int
+    headers: Headers
+    _content: bytes
+    text: str
+
+    @property
+    def content(self) -> bytes:
+        return self._content
+
+    def json(self) -> JsonType:
+        return json.loads(self.text)
+
+
+class AsyncRequest(AsyncContextManager['AsyncRequest']):
+    def __init__(self) -> None:
+        # self._logger = logging.getLogger(__name__)
+        self._ssl_context = self._create_optimized_ssl_context()
+        self._client: Optional[httpx.AsyncClient] = None
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def _create_optimized_ssl_context() -> ssl.SSLContext:
+        """Create an SSL context optimized for performance"""
+        ctx = ssl._create_default_https_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        ctx.set_alpn_protocols(['http/1.1'])
+        ctx.post_handshake_auth = True
+        return ctx
+
+    async def request(
+        self,
+        url: str,
+        method: HttpMethod = "GET",
+        headers: Optional[Headers] = None,
+        cookies: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        json_data: Optional[JsonType] = None,
+        files: Optional[Dict[str, FileData]] = None,
+        proxy: Optional[str] = None,
+        timeout_request: int = 60,
+        max_attempt: int = 10,
+        force_response: bool = False,
+        json_response: bool = False,
+        json_response_check: Optional[str] = None,
+        skip_response: Optional[Union[str, list[str]]] = None,
+        exception_sleep: float = 10,
+        add_user_agent: bool = False
+    ) -> Optional[Response]:
+        """Execute an HTTP request with type handling and automatic retry"""
+        # Prepare headers
+        request_headers = dict(headers or {})
+        if add_user_agent:
+            request_headers["User-Agent"] = await _get_user_agent()
+
+        # Initialize client if not already done
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                verify=self._ssl_context,
+                timeout=timeout_request,
+                cookies=cookies,
+                headers=request_headers,
+                proxy=proxy,
+                follow_redirects=True,
+                # http2=True  # Enable HTTP/2 for better performance
+            )
+
+        # Prepare files for multipart/form-data
+        files_dict = None
+        if files:
+            files_dict = {}
+            for field_name, (filename, content, content_type) in files.items():
+                files_dict[field_name] = (filename, content, content_type)
+
+        if params:
+            params = {k: v for k, v in params.items() if v}
+        for attempt in range(max_attempt):
+            try:
+                # Execute request with all necessary parameters
+                httpx_response = await self._client.request(
+                    method=method,
+                    url=url,
+                    params=params,
+                    json=json_data,
+                    files=files_dict,
+                )
+
+                # Create custom Response object
+                response = Response(
+                    status_code=httpx_response.status_code,
+                    headers=dict(httpx_response.headers),
+                    _content=httpx_response.content,
+                    text=httpx_response.text
+                )
+
+                # Handle unsuccessful status codes
+                if response.status_code not in range(200, 300):
+                    logger.warning(
+                        f"Request: {response.status_code}\n"
+                        f"Attempt {attempt}/{max_attempt}\n"
+                        f"Url: {url}\n"
+                        f"Params: {params}\n"
+                        f"Response: {response.text[:1000]}\n"
+                        f"Request data: {json_data}\n"
+                    )
+                    if skip_response:
+                        patterns = [skip_response] if isinstance(
+                            skip_response, str) else skip_response
+                        # Skip if patterns list is empty
+                        if patterns and any(pattern in response.text for pattern in patterns if pattern):
+                            return response if force_response else None
+
+                    if attempt + 1 == max_attempt:
+                        return response if force_response else None
+
+                    await asyncio.sleep(exception_sleep)
+                    continue
+
+                # Validate JSON response
+                if json_response:
+                    try:
+                        data = response.json()
+                        if json_response_check and json_response_check not in data:
+                            if attempt + 1 == max_attempt:
+                                return None
+                            await asyncio.sleep(exception_sleep)
+                            continue
+                    except json.JSONDecodeError:
+                        if attempt + 1 == max_attempt:
+                            return None
+                        await asyncio.sleep(exception_sleep)
+                        continue
+
+                return response
+
+            except Exception as e:
+                logger.error(
+                    f"Request error: {e} - {url} - attempt {attempt + 1}/{max_attempt}")
+                if attempt + 1 == max_attempt:
+                    return None
+                await asyncio.sleep(exception_sleep)
+                continue
+
+        return None
+
+    async def __aenter__(self) -> 'AsyncRequest':
+        """Context manager entry point"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit point"""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+
+async def make_request(
+    url: str,
+    method: HttpMethod = "GET",
+    headers: Optional[Headers] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    params: Optional[Dict[str, Any]] = None,
+    json_data: Optional[JsonType] = None,
+    files: Optional[Dict[str, FileData]] = None,
+    proxy: Optional[str] = None,
+    timeout_request: int = 60,
+    max_attempt: int = 10,
+    force_response: bool = False,
+    json_response: bool = False,
+    json_response_check: Optional[str] = None,
+    skip_response: Optional[Union[str, list[str]]] = None,
+    exception_sleep: float = 10,
+    add_user_agent: bool = False,
+) -> Optional[Response]:
+    """Main function to execute HTTP requests using shared client for connection reuse"""
+    # Use shared client to avoid "Too many open files" error
+    client = await _get_shared_client()
+
+    # Prepare headers
+    request_headers = dict(headers or {})
+    if add_user_agent:
+        request_headers["User-Agent"] = await _get_user_agent()
+
+    # Prepare files for multipart/form-data
+    files_dict = None
+    if files:
+        files_dict = {}
+        for field_name, (filename, content, content_type) in files.items():
+            files_dict[field_name] = (filename, content, content_type)
+
+    if params:
+        params = {k: v for k, v in params.items() if v}
+
+    for attempt in range(max_attempt):
+        try:
+            # Execute request with all necessary parameters
+            httpx_response = await client.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json_data,
+                files=files_dict,
+                headers=request_headers,
+                timeout=timeout_request,
+            )
+
+            # Create custom Response object
+            response = Response(
+                status_code=httpx_response.status_code,
+                headers=dict(httpx_response.headers),
+                _content=httpx_response.content,
+                text=httpx_response.text
+            )
+
+            # Handle unsuccessful status codes
+            if response.status_code not in range(200, 300):
+                logger.warning(
+                    f"Request: {response.status_code}\n"
+                    f"Attempt {attempt}/{max_attempt}\n"
+                    f"Url: {url}\n"
+                    f"Params: {params}\n"
+                    f"Response: {response.text[:1000]}\n"
+                    f"Request data: {json_data}\n"
+                )
+                if skip_response:
+                    patterns = [skip_response] if isinstance(
+                        skip_response, str) else skip_response
+                    if patterns and any(pattern in response.text for pattern in patterns if pattern):
+                        return response if force_response else None
+
+                if attempt + 1 == max_attempt:
+                    return response if force_response else None
+
+                await asyncio.sleep(exception_sleep)
+                continue
+
+            # Validate JSON response
+            if json_response:
+                try:
+                    data = response.json()
+                    if json_response_check and json_response_check not in data:
+                        if attempt + 1 == max_attempt:
+                            return None
+                        await asyncio.sleep(exception_sleep)
+                        continue
+                except json.JSONDecodeError:
+                    if attempt + 1 == max_attempt:
+                        return None
+                    await asyncio.sleep(exception_sleep)
+                    continue
+
+            return response
+
+        except Exception as e:
+            logger.error(
+                f"Request error: {e} - {url} - attempt {attempt + 1}/{max_attempt}")
+            if attempt + 1 == max_attempt:
+                return None
+            await asyncio.sleep(exception_sleep)
+            continue
+
+    return None
+
+
+@lru_cache(maxsize=1)
+def _get_session_cffi() -> AsyncSession:
+    """Cached session factory with optimized settings."""
+    return AsyncSession(
+        impersonate="chrome",
+        timeout=30.0,
+        headers={'User-Agent': 'Mozilla/5.0 (compatible; Scraper)'}
+    )
+
+
+async def make_request_cffi(url: str) -> Optional[str]:
+    """Optimized HTTP client with connection reuse and error handling."""
+    try:
+        response = await _get_session_cffi().get(url)
+        print(response)
+        response.raise_for_status()
+        return response.text
+    except Exception:
+        return None
+
+
+async def test_proxy():
+    async with httpx.AsyncClient(proxy="http://0ce896d23159e7829ffc__cr.us:e4ada3ce93ad55ca@gw.dataimpesulse.com:823", timeout=10, verify=False) as client:
+        try:
+            r = await client.get("https://api.geckoterminal.com/api/v2/networks/zora-network/trending_pools?include=base_token%2C%20quote_token%2C%20dex&page=1")
+            print(f"Proxy test: {r.status_code} {r.text}")
+        except Exception as e:
+            print(f"Proxy test failed: {e}")
+
+
+async def test_make_request_cffi():
+    url = "https://gmgn.ai/eth/token/0xeee2a64ae321964f969299ced0f4fcadcb0a1141"
+    r = await make_request_cffi(url)
+    print(r)
+
+if __name__ == "__main__":
+    # asyncio.run(make_request("https://api.geckoterminal.com/api/v2/networks/zora-network/trending_pools?include=base_token%2C%20quote_token%2C%20dex&page=1", method="GET"))
+    # asyncio.run(test_proxy())
+    asyncio.run(test_make_request_cffi())

esuls/utils.py

@@ -0,0 +1,29 @@
+"""
+General utilities - no external dependencies required
+"""
+import asyncio
+from typing import Awaitable, Callable, List, TypeVar
+
+T = TypeVar("T")
+
+
+async def run_parallel(
+    *functions: Callable[[], Awaitable[T]],
+    limit: int = 20
+) -> List[T]:
+    """
+    run parallel multiple functions
+    """
+    semaphore = asyncio.Semaphore(limit)
+
+    async def limited_function(func: Callable[[], Awaitable[T]]) -> T:
+        async with semaphore:
+            return await func()
+
+    tasks = [asyncio.create_task(limited_function(func)) for func in functions]
+
+    results = []
+    for fut in asyncio.as_completed(tasks):
+        results.append(await fut)
+
+    return results

esuls-0.1.0.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: esuls
+Version: 0.1.0
+Summary: Utility library for async database operations, HTTP requests, and parallel execution
+Author-email: IperGiove <ipergiove@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ipergiove/esuls
+Project-URL: Repository, https://github.com/ipergiove/esuls
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: curl-cffi>=0.13.0
+Requires-Dist: fake-useragent>=2.2.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: loguru>=0.7.3
+Dynamic: license-file
+
+# esuls
+
+A Python utility library for async database operations, HTTP requests, and parallel execution utilities.
+
+## Features
+
+- **AsyncDB** - Type-safe async SQLite with dataclass schemas
+- **Async HTTP client** - High-performance HTTP client with retry logic and connection pooling
+- **Parallel utilities** - Async parallel execution with concurrency control
+- **CloudFlare bypass** - curl-cffi integration for bypassing protections
+
+## Installation
+
+```bash
+# With pip
+pip install esuls
+
+# With uv
+uv pip install esuls
+```
+
+## Usage
+
+### Parallel Execution
+
+```python
+import asyncio
+from esuls import run_parallel
+
+async def fetch_data(id):
+    await asyncio.sleep(1)
+    return f"Data {id}"
+
+async def main():
+    # Run multiple async functions in parallel with concurrency limit
+    results = await run_parallel(
+        lambda: fetch_data(1),
+        lambda: fetch_data(2),
+        lambda: fetch_data(3),
+        limit=20  # Max concurrent tasks
+    )
+    print(results)
+
+asyncio.run(main())
+```
+
+### Database Client (AsyncDB)
+
+```python
+import asyncio
+from dataclasses import dataclass, field
+from esuls import AsyncDB, BaseModel
+
+# Define your schema
+@dataclass
+class User(BaseModel):
+    name: str = field(metadata={"index": True})
+    email: str = field(metadata={"unique": True})
+    age: int = 0
+
+async def main():
+    # Initialize database
+    db = AsyncDB(db_path="users.db", table_name="users", schema_class=User)
+
+    # Save data
+    user = User(name="Alice", email="alice@example.com", age=30)
+    await db.save(user)
+
+    # Save multiple items
+    users = [
+        User(name="Bob", email="bob@example.com", age=25),
+        User(name="Charlie", email="charlie@example.com", age=35)
+    ]
+    await db.save_batch(users)
+
+    # Query data
+    results = await db.find(name="Alice")
+    print(results)
+
+    # Query with filters
+    adults = await db.find(age__gte=18, order_by="-age")
+
+    # Count
+    count = await db.count(age__gte=18)
+
+    # Get by ID
+    user = await db.get_by_id(user_id)
+
+    # Delete
+    await db.delete(user_id)
+
+asyncio.run(main())
+```
+
+**Query Operators:**
+- `field__eq` - Equal (default)
+- `field__gt` - Greater than
+- `field__gte` - Greater than or equal
+- `field__lt` - Less than
+- `field__lte` - Less than or equal
+- `field__neq` - Not equal
+- `field__like` - SQL LIKE
+- `field__in` - IN operator (pass a list)
+
+### HTTP Request Client
+
+```python
+import asyncio
+from esuls import AsyncRequest, make_request
+
+# Using context manager (recommended for multiple requests)
+async def example1():
+    async with AsyncRequest() as client:
+        response = await client.request(
+            url="https://api.example.com/data",
+            method="GET",
+            add_user_agent=True,
+            max_attempt=3,
+            timeout_request=30
+        )
+        if response:
+            data = response.json()
+            print(data)
+
+# Using standalone function (uses shared connection pool)
+async def example2():
+    response = await make_request(
+        url="https://api.example.com/users",
+        method="POST",
+        json_data={"name": "Alice", "email": "alice@example.com"},
+        headers={"Authorization": "Bearer token"},
+        max_attempt=5,
+        force_response=True  # Return response even on error
+    )
+    if response:
+        print(response.status_code)
+        print(response.text)
+
+asyncio.run(example1())
+```
+
+**Request Parameters:**
+- `url` - Request URL
+- `method` - HTTP method (GET, POST, PUT, DELETE, etc.)
+- `headers` - Request headers
+- `cookies` - Cookies dict
+- `params` - URL parameters
+- `json_data` - JSON body
+- `files` - Multipart file upload
+- `proxy` - Proxy URL
+- `timeout_request` - Timeout in seconds (default: 60)
+- `max_attempt` - Max retry attempts (default: 10)
+- `force_response` - Return response even on error (default: False)
+- `json_response` - Validate JSON response (default: False)
+- `json_response_check` - Check for key in JSON response
+- `skip_response` - Skip if text contains pattern(s)
+- `exception_sleep` - Delay between retries in seconds (default: 10)
+- `add_user_agent` - Add random User-Agent header (default: False)
+
+### CloudFlare Bypass
+
+```python
+import asyncio
+from esuls import make_request_cffi
+
+async def fetch_protected_page():
+    html = await make_request_cffi("https://protected-site.com")
+    if html:
+        print(html)
+
+asyncio.run(fetch_protected_page())
+```
+
+## Development
+
+### Project Structure
+
+```
+utils/
+├── pyproject.toml
+├── README.md
+├── LICENSE
+└── src/
+    └── esuls/
+        ├── __init__.py
+        ├── utils.py          # Parallel execution utilities
+        ├── db_cli.py         # AsyncDB with dataclass schemas
+        └── request_cli.py    # Async HTTP client
+```
+
+### Local Development Installation
+
+```bash
+# Navigate to the project
+cd utils
+
+# Install in editable mode with uv
+uv pip install -e .
+
+# Or with pip
+pip install -e .
+```
+
+### Building and Publishing
+
+```bash
+# With uv
+uv build
+twine upload dist/*
+
+# Or with traditional tools
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## Advanced Features
+
+### AsyncDB Schema Definition
+
+```python
+from dataclasses import dataclass, field
+from esuls import BaseModel
+from datetime import datetime
+from typing import Optional, List
+import enum
+
+class Status(enum.Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+@dataclass
+class User(BaseModel):
+    # BaseModel provides: id, created_at, updated_at
+
+    # Indexed field
+    email: str = field(metadata={"index": True, "unique": True})
+
+    # Simple fields
+    name: str = ""
+    age: int = 0
+
+    # Enum support
+    status: Status = Status.ACTIVE
+
+    # JSON-serialized complex types
+    tags: List[str] = field(default_factory=list)
+
+    # Optional fields
+    phone: Optional[str] = None
+
+    # Table constraints (optional)
+    __table_constraints__ = [
+        "CHECK (age >= 0)"
+    ]
+```
+
+### Connection Pooling & Performance
+
+The HTTP client uses:
+- Shared connection pool (prevents "too many open files" errors)
+- Automatic retry with exponential backoff
+- SSL optimization
+- Random User-Agent rotation
+- Cookie and header persistence
+
+## License
+
+MIT License

esuls-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+esuls/__init__.py,sha256=z77yDz8qY_y0dTvy76Sg8_oyNSLSBE8zE1d49EBUb30,467
+esuls/db_cli.py,sha256=YOPBlKpLV4GG5WzcHov6hpZkmW-vaL1BNlBcAm8bz4k,17424
+esuls/request_cli.py,sha256=8wt2MQ4Y3J-vEVacizbbuHLSrENm41UhnnGGzi-DfDE,14277
+esuls/utils.py,sha256=R0peIanodvDrKYFWWdLZ9weIPAUZX787XIjZH40qNo0,677
+esuls-0.1.0.dist-info/licenses/LICENSE,sha256=AY0N01ARt0kbKB7CkByYLqqNQU-yalb-rpv-eXITEWA,1066
+esuls-0.1.0.dist-info/METADATA,sha256=B8AsFkbt5UHrtd3RX_4MUXubvoPd-XyxLX6MIc5jVuE,6928
+esuls-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+esuls-0.1.0.dist-info/top_level.txt,sha256=WWBDHRhQ0DQLBZKD7Un8uFN93GvVQnP4WvJKkvbACVA,6
+esuls-0.1.0.dist-info/RECORD,,

esuls-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

esuls-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 IperGiove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

esuls-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+esuls