init

Author: Eugene Shershen

.idea/.gitignore

@@ -0,0 +1,52 @@
+exclude: (alembic|build|dist|docker|esign|kubernetes|migrations)
+
+default_language_version:
+  python: python3.13
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+        args: [ --fix, --unsafe-fixes ]
+
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.28.0
+    hooks:
+      - id: pyupgrade
+        args:
+          - --py37-plus
+  - repo: https://github.com/myint/autoflake
+    rev: v1.4
+    hooks:
+      - id: autoflake
+        args:
+          - --in-place
+          - --remove-all-unused-imports
+          - --expand-star-imports
+          - --remove-duplicate-keys
+          - --remove-unused-variables
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+  - repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+      - id: black
+  - repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
+    hooks:
+      - id: flake8
+        args:
+          - --max-line-length=79
+          - --ignore=E203, E501, W503
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.982
+    hooks:
+      - id: mypy
+        additional_dependencies:
+          - pydantic
+          - types-ujson

.pre-commit-config.yaml

@@ -28,16 +28,20 @@ def execute(
             if parameters is None:
                 self._result = self._psqlpy_connection.fetch(query)
             else:
-                # 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
-                    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)
+                    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
+                    )
                 else:
-                    self._result = self._psqlpy_connection.fetch(query, parameters)
+                    self._result = self._psqlpy_connection.fetch(
+                        query, parameters
+                    )
 
             # Process the result
             if self._result:
@@ -66,11 +70,11 @@ def execute(
         except Exception as e:
             raise self._convert_exception(e)
 
-    def executemany(self, query: str, parameters_list: List[Union[dict, list, tuple]]):
+    def executemany(
+        self, query: str, parameters_list: List[Union[dict, list, tuple]]
+    ):
         """Execute a query multiple times with different parameters"""
         try:
-            # For executemany, we'll execute each set of parameters individually
-            # In a more sophisticated implementation, you might use psqlpy's batch execution
             total_rowcount = 0
             for parameters in parameters_list:
                 self.execute(query, parameters)
@@ -133,10 +137,10 @@ def close(self):
         self.rowcount = -1
         self.description = None
 
-    def _convert_positional_to_named(self, query: str, param_count: int) -> str:
-        """Convert positional parameters (?) to named parameters (%(param_N)s)"""
-        # This is a simplified implementation
-        # In practice, you'd need more sophisticated SQL parsing
+    def _convert_positional_to_named(
+        self, query: str, param_count: int
+    ) -> str:
+        "Convert positional parameters (?) to named parameters (%(param_N)s)"
         result = query
         for i in range(param_count):
             result = result.replace("?", f"%(param_{i})s", 1)

psqlpy_sqlalchemy/connection.py

@@ -49,7 +49,9 @@ def import_dbapi(cls):
         """Import the psqlpy module as DBAPI"""
         return PsqlpyDBAPI()
 
-    def create_connect_args(self, url: URL) -> Tuple[List[Any], Dict[str, Any]]:
+    def create_connect_args(
+        self, url: URL
+    ) -> Tuple[List[Any], Dict[str, Any]]:
         """Create connection arguments from SQLAlchemy URL"""
         opts = {}
 
@@ -73,7 +75,9 @@ def create_connect_args(self, url: URL) -> Tuple[List[Any], Dict[str, Any]]:
 
                 # Map common PostgreSQL connection parameters
                 if key == "sslmode":
-                    opts["ssl_mode"] = getattr(psqlpy.SslMode, value.upper(), None)
+                    opts["ssl_mode"] = getattr(
+                        psqlpy.SslMode, value.upper(), None
+                    )
                 elif key == "application_name":
                     opts["application_name"] = value
                 elif key == "connect_timeout":

psqlpy_sqlalchemy/dialect.py

@@ -55,12 +55,12 @@ where = ["."]
 include = ["psqlpy_sqlalchemy*"]
 
 [tool.black]
-line-length = 88
+line-length = 79
 target-version = ['py38']
 
 [tool.isort]
 profile = "black"
-line_length = 88
+line_length = 79
 
 [tool.mypy]
 python_version = "3.9"

pyproject.toml

@@ -39,7 +39,8 @@ def test_exception_hierarchy(self):
 
         for exc_name in exceptions:
             self.assertTrue(
-                hasattr(self.dbapi, exc_name), f"Missing DBAPI exception: {exc_name}"
+                hasattr(self.dbapi, exc_name),
+                f"Missing DBAPI exception: {exc_name}",
             )
             exc_class = getattr(self.dbapi, exc_name)
             self.assertTrue(

tests/test_dbapi.py

@@ -5,7 +5,15 @@
 
 import unittest
 
-from sqlalchemy import Column, Integer, MetaData, String, Table, create_engine, text
+from sqlalchemy import (
+    Column,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    create_engine,
+    text,
+)
 from sqlalchemy.schema import CreateTable
 
 
@@ -37,19 +45,23 @@ def test_connection_string_parsing(self):
         """Test connection string parsing"""
         try:
             self.engine = create_engine(
-                "postgresql+psqlpy://testuser:testpass@localhost:5432/testdb?sslmode=require"
+                "postgresql+psqlpy://testuser:testpass@localhost:5432/testdb?sslmode=require"  # noqa
             )
 
             # Test create_connect_args
-            args, kwargs = self.engine.dialect.create_connect_args(self.engine.url)
+            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"]
             for key in expected_keys:
-                self.assertIn(key, kwargs, f"Missing connection parameter: {key}")
+                self.assertIn(
+                    key, kwargs, f"Missing connection parameter: {key}"
+                )
 
             # Verify specific values
             self.assertEqual(kwargs["host"], "localhost")
@@ -124,7 +136,8 @@ def test_dbapi_interface(self):
 
             for exc_name in exceptions:
                 self.assertTrue(
-                    hasattr(dbapi, exc_name), f"Missing DBAPI exception: {exc_name}"
+                    hasattr(dbapi, exc_name),
+                    f"Missing DBAPI exception: {exc_name}",
                 )
 
         except Exception as e:
@@ -137,13 +150,13 @@ def test_mock_connection(self):
                 "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:
                 connection = self.engine.connect()
                 # If we get here, connection succeeded unexpectedly
                 connection.close()
-                self.fail("Connection succeeded unexpectedly without a real database")
+                self.fail(
+                    "Connection succeeded unexpectedly without a real database"
+                )
             except Exception:
                 # This is expected - we don't have a real database
                 # The test passes if an exception is raised