Code quality pipeline (#3)

* Run static code analysis locally

* Integrate tools and fix errors

* Update workflow

* Update workflow

* Update python version in workflow

* Fix linting errors from tests

* Fix linting errors from tests

* Fix isort order on tests

* Change workflow order

* Update .vscode/settings.json

Co-authored-by: Karen <[email protected]>

---------

Co-authored-by: Alex Rehnby-Martin <[email protected]>
Co-authored-by: Karen <[email protected]>

Author: 3 people

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 130

.github/workflows/main.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
         poetry-version: ["1.4.2"]
 
     steps:
@@ -38,5 +38,11 @@ jobs:
           poetry-version: ${{ matrix.poetry-version }}
       - name: Install dependencies
         run: poetry install
+      - name: Run mypy - static type checking
+        run: poetry run mypy .
+      - name: Run flake8 - linting
+        run: poetry run flake8 .
+      - name: Run isort - dependeny import sorting check
+        run: poetry run isort --check-only .
       - name: Run unit tests
         run: poetry run python -m pytest

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.linting.mypyEnabled": false,
+    "python.linting.enabled": true,
+    "python.linting.flake8Enabled": true
+}

aws_wrapper/__init__.py

@@ -9,4 +9,3 @@
 apilevel = "2.0"
 threadsafety = 2
 paramstyle = "pyformat"
-

aws_wrapper/pep249.py

@@ -14,8 +14,10 @@
           |__NotSupportedError
 
 """
+# mypy: ignore-errors
+
+from typing import Any, Iterator, List, Optional, Sequence
 
-from typing import Any, List, Iterator, Sequence
 
 class Warning(Exception):
     __module__ = "pawswrapper"
@@ -68,16 +70,17 @@ class NotSupportedError(DatabaseError):
 class ConnectionTimeout(OperationalError):
     ...
 
+
 class PipelineAborted(OperationalError):
     ...
 
+
 class Connection:
 
     __module__ = "pawswrapper"
 
     @staticmethod
     def connect(
-        cls,
         conninfo: str = "",
         **kwargs
     ) -> Any:
@@ -168,5 +171,5 @@ def __iter__(self) -> Iterator[Any]:
     def setinputsizes(self, sizes: Any) -> None:
         ...
 
-    def setoutputsize(self, size: Any, column: int = None) -> None:
+    def setoutputsize(self, size: Any, column: Optional[int] = None) -> None:
         ...

aws_wrapper/wrapper.py

@@ -3,50 +3,52 @@
 
 """
 
-from ast import Num
-from typing import Any, Callable, Sequence, cast, Dict, Generator, Generic, Iterator
-from typing import List, NamedTuple, Optional, Type, TypeVar, Tuple, Union
-from typing import overload
+from typing import Any, Callable, Dict, Iterator, List, Optional, Union
+
 from .pep249 import Connection, Cursor, Error
 
+
 class HostInfo:
     url: str
     port: int
 
+
 class Properties(Dict[str, str]):
     ...
 
+
 class Plugin:
 
-    _num: int = 0;
+    _num: int = 0
 
     def __init__(self, num: int):
         self._num = num
 
-    def connect(self, hostInfo: HostInfo, props: Properties, initial: bool, executeFunc: Callable) -> Any:
-        #print("Plugin {}: connect before".format(self._num))
-        result = executeFunc();
-        #print("Plugin {}: connect after".format(self._num))
+    def connect(self, hostInfo: HostInfo, props: Properties,
+                initial: bool, executeFunc: Callable) -> Any:
+        # print("Plugin {}: connect before".format(self._num))
+        result = executeFunc()
+        # print("Plugin {}: connect after".format(self._num))
         return result
 
     def execute(self, executeFunc: Callable) -> Any:
-        #print("Plugin {}: execute before".format(self._num))
-        result = executeFunc();
-        #print("Plugin {}: execute after".format(self._num))
+        # print("Plugin {}: execute before".format(self._num))
+        result = executeFunc()
+        # print("Plugin {}: execute after".format(self._num))
         return result
 
     def subscribed(self, methodName: str) -> bool:
         return True
 
+
 class PluginManager:
 
     _plugins: List[Plugin] = []
-    _numOfPlugins = 0
-    _functionCache: bool = True
-    _executeFunc: Callable = None
-    _connectFunc: Callable = None
+    _executeFunc: Optional[Callable] = None
+    _connectFunc: Optional[Callable] = None
 
-    def __init__(self, props: Properties = Properties(), numOfPlugins: int = 10, functionCache: bool = True):
+    def __init__(self, props: Properties = Properties(),
+                 numOfPlugins: int = 10, functionCache: bool = True):
 
         self._numOfPlugins = numOfPlugins
         self._functionCache = functionCache
@@ -59,7 +61,7 @@ def __init__(self, props: Properties = Properties(), numOfPlugins: int = 10, fun
 
     @property
     def numOfPlugins(self) -> int:
-        return self._numOfPlugins;
+        return self._numOfPlugins
 
     @property
     def executeFunc(self) -> Callable:
@@ -75,11 +77,13 @@ def executeFunc(self) -> Callable:
 
         for i in range(numOfPlugins - 1, 0, -1):
             code = "plugins[{}].execute(lambda : {})".format(i - 1, code)
-        
+
         code = "lambda x : {}".format(code)
-        #print(code)
-        self._executeFunc = eval(code, { "plugins": self._plugins })
+        # print(code)
+
+        self._executeFunc = eval(code, {"plugins": self._plugins})
 
+        assert (self._executeFunc is not None)
         return self._executeFunc
 
     @property
@@ -96,92 +100,92 @@ def connectFunc(self) -> Callable:
 
         for i in range(numOfPlugins - 1, 0, -1):
             code = "plugins[{}].connect(hostInfo, props, initial, lambda : {})".format(i - 1, code)
-        
+
         code = "lambda hostInfo, props, initial, x : {}".format(code)
-        #print(code)
-        self._connectFunc = eval(code, { "plugins": self._plugins })
+        # print(code)
+        self._connectFunc = eval(code, {"plugins": self._plugins})
 
+        assert (self._connectFunc is not None)
         return self._connectFunc
 
 
 class AwsWrapperConnection(Connection):
 
     __module__ = "pawswrapper"
-    
-    _targetConn: Connection = None
-    _pluginManager: PluginManager = None
+
+    def __init__(self, pluginManager: PluginManager, targetConn: Connection):
+        self._targetConn = targetConn
+        self._pluginManager = pluginManager
 
     @staticmethod
     def connect(
         conninfo: str = "",
-        target: Union[str, callable] = None,
+        target: Union[None, str, Callable] = None,
         **kwargs: Union[None, int, str]
     ) -> "AwsWrapperConnection":
         # Check if target provided
         if not target:
             raise Error("Target driver is required")
 
         if type(target) == str:
-            target = eval(target);
+            target = eval(target)
 
         if not callable(target):
             raise Error("Target driver should be a target driver's connect() method/function")
 
         numOfPlugins = kwargs.get("numOfPlugins")
-        if numOfPlugins == None:
-            numOfPlugins = 10
-        else:
+        if numOfPlugins is not None:
             kwargs.pop("numOfPlugins")
+        if type(numOfPlugins) != int:
+            numOfPlugins = 10
+
         functionCache = kwargs.get("functionCache")
-        if functionCache == None:
+        if functionCache is None:
             functionCache = True
         else:
             kwargs.pop("functionCache")
+            functionCache = bool(functionCache)
 
         props: Properties = Properties()
         pluginManager: PluginManager = PluginManager(props=props, numOfPlugins=numOfPlugins, functionCache=functionCache)
         hostInfo: HostInfo = HostInfo()
 
-
         # Target driver is a connect function
         if pluginManager.numOfPlugins == 0:
             conn = target(conninfo, **kwargs)
         else:
-            conn = pluginManager.connectFunc(hostInfo, props, True, lambda : target(conninfo, **kwargs))
-
-        return AwsWrapperConnection(pluginManager, conn);
+            conn = pluginManager.connectFunc(hostInfo, props, True, lambda: target(conninfo, **kwargs))
 
-    def __init__(self, pluginManager: PluginManager, targetConn: Connection):
-        self._targetConn = targetConn
-        self._pluginManager = pluginManager
+        return AwsWrapperConnection(pluginManager, conn)
 
     def close(self) -> None:
-        self._targetConn.close();
+        if self._targetConn:
+            self._targetConn.close()
 
     def cursor(self, **kwargs) -> "AwsWrapperCursor":
         _cursor = self._targetConn.cursor(**kwargs)
-        return AwsWrapperCursor(self, self._pluginManager, _cursor);
+        return AwsWrapperCursor(self, self._pluginManager, _cursor)
 
     def commit(self) -> None:
-        self._targetConn.commit();
+        self._targetConn.commit()
 
     def rollback(self) -> None:
-        self._targetConn.rollback();
+        self._targetConn.rollback()
 
     def tpc_begin(self, xid: Any) -> None:
-        self._targetConn.tpc_begin(xid);
+        self._targetConn.tpc_begin(xid)
 
     def tpc_prepare(self) -> None:
-        self._targetConn.tpc_prepare();
+        self._targetConn.tpc_prepare()
 
     def tpc_commit(self, xid: Any = None) -> None:
-        self._targetConn.tpc_commit(xid);
+        self._targetConn.tpc_commit(xid)
 
     def tpc_rollback(self, xid: Any = None) -> None:
-        self._targetConn.tpc_rollback(xid);
+        self._targetConn.tpc_rollback(xid)
 
     def tpc_recover(self) -> Any:
-        return self._targetConn.tpc_recover();
+        return self._targetConn.tpc_recover()
 
     def __enter__(self: "AwsWrapperConnection") -> "AwsWrapperConnection":
         return self
@@ -191,7 +195,6 @@ def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
             self._targetConn.close()
 
 
-
 class AwsWrapperCursor(Cursor):
 
     __module__ = "pawswrapper"
@@ -208,35 +211,36 @@ def __init__(self, conn: AwsWrapperConnection, pluginManager: PluginManager, tar
     # It's not part of PEP249
     @property
     def connection(self) -> AwsWrapperConnection:
-        return self._conn;
+        return self._conn
 
     @property
     def description(self):
-        return self._targetCursor.description;
+        return self._targetCursor.description
 
     @property
     def rowcount(self) -> int:
-        return self._targetCursor.rowcount;
+        return self._targetCursor.rowcount
 
     @property
     def arraysize(self) -> int:
-        return self._targetCursor.arraysize;
+        return self._targetCursor.arraysize
 
     def close(self) -> None:
-        return self._targetCursor.close;
+        self._targetCursor.close
 
     def callproc(self, **kwargs):
-        return self._targetCursor.callproc(**kwargs);
+        return self._targetCursor.callproc(**kwargs)
 
     def execute(
         self,
         query: str,
         **kwargs
     ) -> "AwsWrapperCursor":
         if self._pluginManager.numOfPlugins == 0:
-            return self._targetCursor.execute(query, **kwargs)
+            self._targetCursor = self._targetCursor.execute(query, **kwargs)
+            return self
 
-        result = self._pluginManager.executeFunc(lambda : self._targetCursor.execute(query, **kwargs))
+        result = self._pluginManager.executeFunc(lambda: self._targetCursor.execute(query, **kwargs))
         return result
 
     def executemany(
@@ -264,12 +268,11 @@ def __iter__(self) -> Iterator[Any]:
     def setinputsizes(self, sizes: Any) -> None:
         return self._targetCursor.setinputsizes(sizes)
 
-    def setoutputsize(self, size: Any, column: int = None) -> None:
+    def setoutputsize(self, size: Any, column: Optional[int] = None) -> None:
         return self._targetCursor.setoutputsize(size, column)
 
     def __enter__(self: "AwsWrapperCursor") -> "AwsWrapperCursor":
         return self
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         self.close()
-