checkmate5 4.0.79__tar.gz → 4.0.80__tar.gz

{checkmate5-4.0.79/checkmate5.egg-info → checkmate5-4.0.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: checkmate5
-Version: 4.0.79
+Version: 4.0.80
 Summary: A meta-code checker written in Python.
 Author: Andreas Dewes
 License: AGPL-3.0

{checkmate5-4.0.79 → checkmate5-4.0.80/checkmate5.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: checkmate5
-Version: 4.0.79
+Version: 4.0.80
 Summary: A meta-code checker written in Python.
 Author: Andreas Dewes
 License: AGPL-3.0

checkmate5-4.0.80/lib/models.py

@@ -0,0 +1,96 @@
+from blitzdb import Document
+from blitzdb.backends.sql.backend import Backend as BlitzDBBackend
+from typing import Any, Optional, Dict
+import logging
+from contextlib import contextmanager
+
+logger = logging.getLogger(__name__)
+
+class Backend(BlitzDBBackend):
+    def __init__(self, engine: Any, backend_type: str = 'sql', pool_size: int = 5) -> None:
+        """Initialize BlitzDB backend with specified engine and type.
+        
+        Args:
+            engine: SQL connection engine or file path depending on backend_type
+            backend_type: Type of backend ('sql' or 'sqlfile')
+            pool_size: Connection pool size for SQL backend
+            
+        Raises:
+            ValueError: If backend_type is not supported
+        """
+        if backend_type not in ['sql', 'sqlfile']:
+            raise ValueError(f"Unsupported backend type: {backend_type}")
+            
+        self.backend_type = backend_type
+        self.engine = engine
+        self.pool_size = pool_size
+        
+        backend_params = {
+            'sql': {
+                'connection': engine,
+                'backend': 'sql',
+                'pool_size': pool_size
+            },
+            'sqlfile': {
+                'path': engine,
+                'backend': 'sqlfile'
+            }
+        }.get(backend_type)
+        
+        logger.debug(f"Initializing {backend_type} backend with params: {backend_params}")
+        super().__init__(**backend_params)
+
+    def test_connection(self) -> bool:
+        """Test the backend connection.
+        
+        Returns:
+            bool: True if connection is successful
+            
+        Raises:
+            ConnectionError: If connection test fails
+        """
+        try:
+            if self.backend_type == 'sql':
+                with self.engine.connect() as conn:
+                    conn.execute('SELECT 1')
+            elif self.backend_type == 'sqlfile':
+                # Test file access
+                with open(self.engine, 'a+') as _:
+                    pass
+            logger.info(f"Connection test successful for {self.backend_type} backend")
+            return True
+        except Exception as e:
+            logger.error(f"Connection test failed: {str(e)}")
+            raise ConnectionError(f"Connection test failed: {str(e)}")
+
+    @contextmanager
+    def session(self):
+        """Context manager for database sessions.
+        
+        Yields:
+            Backend: Self with active session
+            
+        Example:
+            with backend.session() as session:
+                session.save(document)
+        """
+        try:
+            yield self
+            self.commit()
+        except Exception as e:
+            logger.error(f"Session error: {str(e)}")
+            self.rollback()
+            raise
+        finally:
+            if self.backend_type == 'sql':
+                self.engine.dispose()
+
+    def close(self) -> None:
+        """Properly close backend connections."""
+        try:
+            if self.backend_type == 'sql':
+                self.engine.dispose()
+            logger.info(f"Closed {self.backend_type} backend connection")
+        except Exception as e:
+            logger.error(f"Error closing backend: {str(e)}")
+            raise 

checkmate5-4.0.80/management/helpers.py

@@ -0,0 +1,110 @@
+from typing import Any, Dict, Optional
+from sqlalchemy import create_engine
+from sqlalchemy.pool import QueuePool
+import logging
+from ..lib.models import Backend
+from ..exceptions import ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+def validate_config(config: Dict[str, Any]) -> None:
+    """Validate the configuration dictionary.
+    
+    Args:
+        config: Configuration dictionary to validate
+        
+    Raises:
+        ConfigurationError: If configuration is invalid
+    """
+    required_fields = {
+        'sql': ['host', 'database', 'user'],
+        'sqlfile': []
+    }
+    
+    backend_type = config.get('backend', {}).get('type', 'sql')
+    if backend_type not in required_fields:
+        raise ConfigurationError(f"Invalid backend type: {backend_type}")
+        
+    for field in required_fields[backend_type]:
+        if not config.get('backend', {}).get(field):
+            raise ConfigurationError(f"Missing required field: {field}")
+
+def get_connection_string(config: Dict[str, Any]) -> str:
+    """Generate database connection string from config.
+    
+    Args:
+        config: Configuration dictionary
+        
+    Returns:
+        str: Database connection string
+        
+    Raises:
+        ConfigurationError: If connection string cannot be generated
+    """
+    try:
+        backend = config.get('backend', {})
+        template = "postgresql://{user}:{password}@{host}:{port}/{database}"
+        return template.format(
+            user=backend.get('user'),
+            password=backend.get('password', ''),
+            host=backend.get('host', 'localhost'),
+            port=backend.get('port', 5432),
+            database=backend.get('database')
+        )
+    except Exception as e:
+        raise ConfigurationError(f"Failed to generate connection string: {str(e)}")
+
+def get_backend(
+    project_path: str,
+    project_config: Dict[str, Any],
+    settings: Optional[Dict[str, Any]] = None
+) -> Backend:
+    """Create and return appropriate backend based on project configuration.
+    
+    Args:
+        project_path: Path to the project
+        project_config: Project configuration dictionary
+        settings: Optional additional settings
+        
+    Returns:
+        Initialized Backend instance
+        
+    Raises:
+        ConfigurationError: If configuration is invalid
+        ConnectionError: If database connection fails
+    """
+    try:
+        # Validate configuration
+        validate_config(project_config)
+        
+        backend_type = project_config.get('backend', {}).get('type', 'sql')
+        pool_size = settings.get('pool_size', 5) if settings else 5
+        
+        logger.info(f"Initializing {backend_type} backend")
+        
+        if backend_type == 'sql':
+            connection_string = get_connection_string(project_config)
+            engine = create_engine(
+                connection_string,
+                poolclass=QueuePool,
+                pool_size=pool_size,
+                max_overflow=10,
+                pool_timeout=30
+            )
+        elif backend_type == 'sqlfile':
+            if not project_path:
+                raise ConfigurationError("Project path is required for sqlfile backend")
+            engine = project_path
+        else:
+            raise ConfigurationError(f"Unknown backend type: {backend_type}")
+        
+        backend = Backend(engine, backend_type, pool_size)
+        
+        # Test connection
+        backend.test_connection()
+        
+        return backend
+        
+    except Exception as e:
+        logger.error(f"Backend initialization failed: {str(e)}")
+        raise 

{checkmate5-4.0.79 → checkmate5-4.0.80}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "checkmate5"
-version = "4.0.79"
+version = "4.0.80"
 authors = [
     { name = "Andreas Dewes" }
 ]

{checkmate5-4.0.79 → checkmate5-4.0.80}/setup.py

@@ -24,7 +24,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='checkmate5',
-    version='4.0.79',
+    version='4.0.80',
     license='MIT',
     install_requires=[
         'blitzdb5',

checkmate5-4.0.79/lib/models.py

@@ -1 +0,0 @@
- 

checkmate5-4.0.79/management/helpers.py

@@ -1 +0,0 @@
-