init

Author: Eugene Shershen

.gitignore

@@ -1,3 +1,3 @@
 .idea
 *.egg-info
-.venv
+.venv

README.md

@@ -218,4 +218,4 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 - Connection string parsing
 - Basic SQL compilation support
 - Transaction support
-- SSL configuration support
+- SSL configuration support

psqlpy_sqlalchemy/connection.py

@@ -2,7 +2,7 @@
 DBAPI-compatible connection and cursor wrappers for psqlpy
 """
 
-from typing import Any, List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import psqlpy
 
@@ -31,7 +31,8 @@ def execute(
                 # Convert parameters to psqlpy format if needed
                 if isinstance(parameters, (list, tuple)):
                     # Convert positional parameters to named parameters
-                    # This is a simplified conversion - in practice, you might need more sophisticated handling
+                    # This is a simplified conversion - in practice, you might need more
+                    # sophisticated handling
                     param_dict = {f"param_{i}": val for i, val in enumerate(parameters)}
                     query = self._convert_positional_to_named(query, len(parameters))
                     self._result = self._psqlpy_connection.fetch(query, param_dict)
@@ -171,7 +172,8 @@ def commit(self):
         # If we're in a transaction, we need to commit it
         if self._in_transaction:
             try:
-                # This is a simplified approach - in practice you'd track transactions better
+                # This is a simplified approach - in practice you'd track
+                # transactions better
                 cursor = self.cursor()
                 cursor.execute("COMMIT")
                 self._in_transaction = False
@@ -196,7 +198,7 @@ def close(self):
         if not self._closed:
             try:
                 self._psqlpy_connection.close()
-            except:
+            except Exception:
                 pass  # Ignore errors on close
             self._closed = True
 

psqlpy_sqlalchemy/dbapi.py

@@ -2,7 +2,6 @@
 DBAPI-compatible interface for psqlpy
 """
 
-from typing import Any, Optional
 
 import psqlpy
 

psqlpy_sqlalchemy/dialect.py

@@ -2,14 +2,11 @@
 SQLAlchemy dialect for psqlpy
 """
 
-from typing import Any, Dict, List, Optional, Tuple, Union
-from urllib.parse import parse_qs, urlparse
+from typing import Any, Dict, List, Tuple
 
 import psqlpy
-from sqlalchemy import pool, util
-from sqlalchemy.engine import default, interfaces
+from sqlalchemy.engine import default
 from sqlalchemy.engine.url import URL
-from sqlalchemy.sql import sqltypes
 
 from .connection import PsqlpyConnection
 from .dbapi import PsqlpyDBAPI
@@ -148,7 +145,7 @@ def get_isolation_level(self, dbapi_connection):
             if result:
                 level = result[0].upper().replace(" ", "_")
                 return level
-        except:
+        except Exception:
             pass
         return self.default_isolation_level
 
@@ -171,7 +168,8 @@ def _handle_exception(self, e):
         """Convert psqlpy exceptions to appropriate DBAPI exceptions"""
         if isinstance(e, psqlpy.Error):
             # For now, just re-raise as is
-            # In a full implementation, we'd map to specific DBAPI exception types
+            # In a full implementation, we'd map to specific DBAPI
+            # exception types
             return e
         return e
 

pyproject.toml

@@ -92,4 +92,4 @@ ignore_errors = true
 
 [[tool.mypy.overrides]]
 module = "tests.*"
-ignore_errors = true
+ignore_errors = true

tests/test_dbapi.py

@@ -25,17 +25,26 @@ def test_dbapi_attributes(self):
     def test_exception_hierarchy(self):
         """Test that all required DBAPI exceptions are available"""
         exceptions = [
-            'Warning', 'Error', 'InterfaceError', 'DatabaseError',
-            'DataError', 'OperationalError', 'IntegrityError',
-            'InternalError', 'ProgrammingError', 'NotSupportedError'
+            "Warning",
+            "Error",
+            "InterfaceError",
+            "DatabaseError",
+            "DataError",
+            "OperationalError",
+            "IntegrityError",
+            "InternalError",
+            "ProgrammingError",
+            "NotSupportedError",
         ]
-        
+
         for exc_name in exceptions:
-            self.assertTrue(hasattr(self.dbapi, exc_name), 
-                          f"Missing DBAPI exception: {exc_name}")
+            self.assertTrue(
+                hasattr(self.dbapi, exc_name), f"Missing DBAPI exception: {exc_name}"
+            )
             exc_class = getattr(self.dbapi, exc_name)
-            self.assertTrue(callable(exc_class), 
-                          f"Exception {exc_name} is not callable")
+            self.assertTrue(
+                callable(exc_class), f"Exception {exc_name} is not callable"
+            )
 
     def test_type_constructors(self):
         """Test DBAPI type constructors"""
@@ -86,15 +95,15 @@ def test_tick_constructors(self):
 
         # Get current timestamp
         current_time = time.time()
-        
+
         # Test DateFromTicks
         date_from_ticks = self.dbapi.DateFromTicks(current_time)
         self.assertIsInstance(date_from_ticks, datetime.date)
-        
+
         # Test TimeFromTicks
         time_from_ticks = self.dbapi.TimeFromTicks(current_time)
         self.assertIsInstance(time_from_ticks, datetime.time)
-        
+
         # Test TimestampFromTicks
         timestamp_from_ticks = self.dbapi.TimestampFromTicks(current_time)
         self.assertIsInstance(timestamp_from_ticks, datetime.datetime)
@@ -109,9 +118,9 @@ def test_type_objects(self):
 
     def test_connect_method_exists(self):
         """Test that connect method exists"""
-        self.assertTrue(hasattr(self.dbapi, 'connect'))
+        self.assertTrue(hasattr(self.dbapi, "connect"))
         self.assertTrue(callable(self.dbapi.connect))
 
 
-if __name__ == '__main__':
-    unittest.main()
+if __name__ == "__main__":
+    unittest.main()

tests/test_dialect.py

@@ -6,7 +6,6 @@
 import unittest
 
 from sqlalchemy import Column, Integer, MetaData, String, Table, create_engine, text
-from sqlalchemy.orm import sessionmaker
 from sqlalchemy.schema import CreateTable
 
 
@@ -25,7 +24,9 @@ def tearDown(self):
     def test_dialect_registration(self):
         """Test that the dialect is properly registered"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://user:password@localhost/test")
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test"
+            )
             self.assertIsNotNone(self.engine.dialect)
             self.assertEqual(self.engine.dialect.name, "postgresql")
             self.assertEqual(self.engine.dialect.driver, "psqlpy")
@@ -35,86 +36,107 @@ def test_dialect_registration(self):
     def test_connection_string_parsing(self):
         """Test connection string parsing"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://testuser:testpass@localhost:5432/testdb?sslmode=require")
-            
+            self.engine = create_engine(
+                "postgresql+psqlpy://testuser:testpass@localhost:5432/testdb?sslmode=require"
+            )
+
             # Test create_connect_args
             args, kwargs = self.engine.dialect.create_connect_args(self.engine.url)
-            
+
             self.assertIsInstance(args, list)
             self.assertIsInstance(kwargs, dict)
-            
+
             # Check expected connection parameters
-            expected_keys = ['host', 'port', 'db_name', 'username', 'password']
+            expected_keys = ["host", "port", "db_name", "username", "password"]
             for key in expected_keys:
                 self.assertIn(key, kwargs, f"Missing connection parameter: {key}")
-            
+
             # Verify specific values
-            self.assertEqual(kwargs['host'], 'localhost')
-            self.assertEqual(kwargs['port'], 5432)
-            self.assertEqual(kwargs['db_name'], 'testdb')
-            self.assertEqual(kwargs['username'], 'testuser')
-            self.assertEqual(kwargs['password'], 'testpass')
-            
+            self.assertEqual(kwargs["host"], "localhost")
+            self.assertEqual(kwargs["port"], 5432)
+            self.assertEqual(kwargs["db_name"], "testdb")
+            self.assertEqual(kwargs["username"], "testuser")
+            self.assertEqual(kwargs["password"], "testpass")
+
         except Exception as e:
             self.fail(f"Failed to parse connection string: {e}")
 
     def test_basic_sql_compilation(self):
         """Test basic SQL compilation"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://user:password@localhost/test")
-            
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test"
+            )
+
             # Test basic SQL compilation
             stmt = text("SELECT 1 as test_column")
             compiled = stmt.compile(self.engine)
             self.assertIsNotNone(compiled)
             self.assertIn("SELECT 1", str(compiled))
-            
+
             # Test table creation SQL
             metadata = MetaData()
-            test_table = Table('test_table', metadata,
-                Column('id', Integer, primary_key=True),
-                Column('name', String(50))
+            test_table = Table(
+                "test_table",
+                metadata,
+                Column("id", Integer, primary_key=True),
+                Column("name", String(50)),
             )
-            
+
             create_ddl = CreateTable(test_table)
             create_sql = str(create_ddl.compile(self.engine))
             self.assertIsNotNone(create_sql)
             self.assertIn("CREATE TABLE test_table", create_sql)
             self.assertIn("id", create_sql)
             self.assertIn("name", create_sql)
-            
+
         except Exception as e:
             self.fail(f"Failed SQL compilation: {e}")
 
     def test_dbapi_interface(self):
         """Test DBAPI interface"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://user:password@localhost/test")
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test"
+            )
             dbapi = self.engine.dialect.import_dbapi()
-            
+
             self.assertIsNotNone(dbapi)
-            
+
             # Test DBAPI attributes
             self.assertEqual(dbapi.apilevel, "2.0")
             self.assertEqual(dbapi.threadsafety, 2)
             self.assertEqual(dbapi.paramstyle, "pyformat")
-            
+
             # Test exception hierarchy
-            exceptions = ['Warning', 'Error', 'InterfaceError', 'DatabaseError', 
-                         'DataError', 'OperationalError', 'IntegrityError', 
-                         'InternalError', 'ProgrammingError', 'NotSupportedError']
-            
+            exceptions = [
+                "Warning",
+                "Error",
+                "InterfaceError",
+                "DatabaseError",
+                "DataError",
+                "OperationalError",
+                "IntegrityError",
+                "InternalError",
+                "ProgrammingError",
+                "NotSupportedError",
+            ]
+
             for exc_name in exceptions:
-                self.assertTrue(hasattr(dbapi, exc_name), f"Missing DBAPI exception: {exc_name}")
-            
+                self.assertTrue(
+                    hasattr(dbapi, exc_name), f"Missing DBAPI exception: {exc_name}"
+                )
+
         except Exception as e:
             self.fail(f"Failed DBAPI interface test: {e}")
 
     def test_mock_connection(self):
         """Test connection creation (without actual database)"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://user:password@localhost/test")
-            
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test"
+            )
+
             # This will fail because we don't have a real database,
             # but we can test that the connection creation process starts correctly
             try:
@@ -126,17 +148,19 @@ def test_mock_connection(self):
                 # This is expected - we don't have a real database
                 # The test passes if an exception is raised
                 pass
-                
+
         except Exception as e:
             # If we get here, it means the test setup itself failed
             self.fail(f"Unexpected error in connection test setup: {e}")
 
     def test_dialect_capabilities(self):
         """Test dialect capabilities and features"""
         try:
-            self.engine = create_engine("postgresql+psqlpy://user:password@localhost/test")
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test"
+            )
             dialect = self.engine.dialect
-            
+
             # Test key dialect capabilities
             self.assertTrue(dialect.supports_statement_cache)
             self.assertTrue(dialect.supports_multivalues_insert)
@@ -147,7 +171,7 @@ def test_dialect_capabilities(self):
             self.assertTrue(dialect.supports_sequences)
             self.assertTrue(dialect.implicit_returning)
             self.assertTrue(dialect.full_returning)
-            
+
         except Exception as e:
             self.fail(f"Failed dialect capabilities test: {e}")
 
@@ -161,23 +185,23 @@ def test_connection_wrapper_creation(self):
 
         # We can't create a real connection without a database,
         # but we can test the class exists and has required methods
-        self.assertTrue(hasattr(PsqlpyConnection, 'cursor'))
-        self.assertTrue(hasattr(PsqlpyConnection, 'commit'))
-        self.assertTrue(hasattr(PsqlpyConnection, 'rollback'))
-        self.assertTrue(hasattr(PsqlpyConnection, 'close'))
+        self.assertTrue(hasattr(PsqlpyConnection, "cursor"))
+        self.assertTrue(hasattr(PsqlpyConnection, "commit"))
+        self.assertTrue(hasattr(PsqlpyConnection, "rollback"))
+        self.assertTrue(hasattr(PsqlpyConnection, "close"))
 
     def test_cursor_wrapper_creation(self):
         """Test that cursor wrapper can be created"""
         from psqlpy_sqlalchemy.connection import PsqlpyCursor
 
         # Test the class exists and has required methods
-        self.assertTrue(hasattr(PsqlpyCursor, 'execute'))
-        self.assertTrue(hasattr(PsqlpyCursor, 'executemany'))
-        self.assertTrue(hasattr(PsqlpyCursor, 'fetchone'))
-        self.assertTrue(hasattr(PsqlpyCursor, 'fetchmany'))
-        self.assertTrue(hasattr(PsqlpyCursor, 'fetchall'))
-        self.assertTrue(hasattr(PsqlpyCursor, 'close'))
+        self.assertTrue(hasattr(PsqlpyCursor, "execute"))
+        self.assertTrue(hasattr(PsqlpyCursor, "executemany"))
+        self.assertTrue(hasattr(PsqlpyCursor, "fetchone"))
+        self.assertTrue(hasattr(PsqlpyCursor, "fetchmany"))
+        self.assertTrue(hasattr(PsqlpyCursor, "fetchall"))
+        self.assertTrue(hasattr(PsqlpyCursor, "close"))
 
 
-if __name__ == '__main__':
-    unittest.main()
+if __name__ == "__main__":
+    unittest.main()