checkmate5 4.0.87__tar.gz → 4.0.89__tar.gz

{checkmate5-4.0.87/checkmate5.egg-info → checkmate5-4.0.89}/PKG-INFO

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

{checkmate5-4.0.87 → checkmate5-4.0.89}/checkmate/management/helpers.py

@@ -9,7 +9,7 @@ from functools import reduce
 import argparse
 from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String
 from sqlalchemy.exc import SQLAlchemyError
-from checkmate.lib.models import CMFileBackend
+from lib.models import Backend
 
 def get_project_path(path=None):
     if not path:
@@ -91,12 +91,12 @@ def get_backend(project_path, project_config, settings, echo=False, initialize_d
         if not connection_string:
             raise ValueError("Connection string is required for the 'sql' backend.")
         engine = create_engine(connection_string)
-        backend = CMFileBackend(engine)
+        backend = Backend(engine)
     elif backend_type == "sqlite":
         if not connection_string:
             connection_string = f"sqlite:///{project_path}/database.db"
         engine = create_engine(connection_string, echo=echo)
-        backend = CMFileBackend(engine)
+        backend = Backend(engine)
     else:
         raise ValueError("Unsupported backend type specified.")
 

{checkmate5-4.0.87 → checkmate5-4.0.89/checkmate5.egg-info}/PKG-INFO

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

{checkmate5-4.0.87 → checkmate5-4.0.89}/checkmate5.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ CHANGELOG.txt
 LICENSE.txt
 MANIFEST.in
 README.md
+exceptions.py
 pyproject.toml
 setup.py
 checkmate/__init__.py

checkmate5-4.0.89/exceptions.py

@@ -0,0 +1,17 @@
+class ConfigurationError(Exception):
+    """Exception raised for configuration-related errors.
+    
+    Attributes:
+        message -- explanation of the error
+        config -- configuration that caused the error (optional)
+    """
+
+    def __init__(self, message: str, config: dict = None) -> None:
+        self.message = message
+        self.config = config
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        if self.config:
+            return f"{self.message} (Config: {self.config})"
+        return self.message 

checkmate5-4.0.89/lib/models.py

@@ -0,0 +1,119 @@
+from blitzdb import FileBackend as BlitzDBFileBackend
+from blitzdb.backends.sql import Backend as BlitzDBSQLBackend
+from typing import Any, Optional, Dict
+import logging
+from contextlib import contextmanager
+
+logger = logging.getLogger(__name__)
+
+class FileBackend(BlitzDBFileBackend):
+    def __init__(self, path: str) -> None:
+        """Initialize FileBackend with specified path.
+        
+        Args:
+            path: Path to store the database files
+            
+        Raises:
+            ValueError: If path is invalid
+        """
+        logger.debug(f"Initializing FileBackend with path: {path}")
+        super().__init__(path)
+        self.path = path
+
+    def test_connection(self) -> bool:
+        """Test the file access.
+        
+        Returns:
+            bool: True if file access is successful
+            
+        Raises:
+            ConnectionError: If file access test fails
+        """
+        try:
+            self.begin()
+            self.commit()
+            logger.info("File access test successful")
+            return True
+        except Exception as e:
+            logger.error(f"File access test failed: {str(e)}")
+            raise ConnectionError(f"File access test failed: {str(e)}")
+
+    @contextmanager
+    def session(self):
+        """Context manager for file operations.
+        
+        Yields:
+            FileBackend: Self with active session
+        """
+        try:
+            self.begin()
+            yield self
+            self.commit()
+        except Exception as e:
+            logger.error(f"Session error: {str(e)}")
+            self.rollback()
+            raise
+
+class SQLBackend(BlitzDBSQLBackend):
+    def __init__(self, connection: Any) -> None:
+        """Initialize SQL Backend with database connection.
+        
+        Args:
+            connection: SQLAlchemy engine or connection object
+            
+        Raises:
+            ConnectionError: If database connection fails
+        """
+        logger.debug(f"Initializing SQL Backend with connection: {connection}")
+        super().__init__(connection)
+        self.connection = connection
+
+    def test_connection(self) -> bool:
+        """Test the database connection.
+        
+        Returns:
+            bool: True if connection is successful
+            
+        Raises:
+            ConnectionError: If connection test fails
+        """
+        try:
+            with self.connection.connect() as conn:
+                conn.execute('SELECT 1')
+            logger.info("Database connection test successful")
+            return True
+        except Exception as e:
+            logger.error(f"Database connection test failed: {str(e)}")
+            raise ConnectionError(f"Database connection test failed: {str(e)}")
+
+    @contextmanager
+    def session(self):
+        """Context manager for database sessions.
+        
+        Yields:
+            SQLBackend: Self with active session
+        """
+        try:
+            self.begin()
+            yield self
+            self.commit()
+        except Exception as e:
+            logger.error(f"Session error: {str(e)}")
+            self.rollback()
+            raise
+        finally:
+            if hasattr(self.connection, 'dispose'):
+                self.connection.dispose()
+
+    def close(self) -> None:
+        """Clean up database connections."""
+        try:
+            if hasattr(self.connection, 'dispose'):
+                self.connection.dispose()
+            logger.info("Closed SQL Backend connection")
+        except Exception as e:
+            logger.error(f"Error closing backend: {str(e)}")
+            raise
+
+# For backward compatibility
+Backend = SQLBackend  # Default to SQLBackend for existing code

{checkmate5-4.0.87 → checkmate5-4.0.89}/management/helpers.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict, Optional
-from sqlalchemy import create_engine
-from sqlalchemy.pool import QueuePool
 import logging
-from checkmate.lib.models import Backend
+import os
+from sqlalchemy import create_engine
+from ..lib.models import FileBackend, SQLBackend
 from ..exceptions import ConfigurationError
 
 logger = logging.getLogger(__name__)
@@ -58,8 +58,8 @@ 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.
+) -> Any:
+    """Create and return appropriate backend based on configuration.
     
     Args:
         project_path: Path to the project
@@ -67,38 +67,24 @@ def get_backend(
         settings: Optional additional settings
         
     Returns:
-        Initialized Backend instance
+        FileBackend or SQLBackend instance
         
     Raises:
         ConfigurationError: If configuration is invalid
-        ConnectionError: If database connection fails
+        ConnectionError: If 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':
+            engine = create_engine(connection_string)
+            backend = SQLBackend(engine)
+        else:  # default to file backend
             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)
+                raise ConfigurationError("Project path is required for file backend")
+            os.makedirs(project_path, exist_ok=True)
+            backend = FileBackend(project_path)
         
         # Test connection
         backend.test_connection()

{checkmate5-4.0.87 → checkmate5-4.0.89}/pyproject.toml

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

{checkmate5-4.0.87 → checkmate5-4.0.89}/setup.py

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

checkmate5-4.0.87/lib/models.py

@@ -1,96 +0,0 @@
-from blitzdb import Document
-from blitzdb.backends.file.backend import Backend as FileBackend
-from typing import Any, Optional, Dict
-import logging
-from contextlib import contextmanager
-
-logger = logging.getLogger(__name__)
-
-class Backend(FileBackend):
-    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