Merge pull request #96 from Mause/all-repos_autofix_add_mypy_config_v2

Add strict mypy config

Author: Mause

.pre-commit-config.yaml

@@ -38,6 +38,9 @@ repos:
     rev: v0.910
     hooks:
      - id: mypy
+       additional_dependencies:
+          - "pytest==6.2.4"
+          - "hypothesis==6.14.1"
   - repo: https://github.com/PyCQA/flake8
     rev: '3.9.2'  # pick a git hash / tag to point to
     hooks:

duckdb_engine/__init__.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass, field
-from typing import List
+from typing import Any, Dict, List, Tuple, Type
 
 import duckdb
 from sqlalchemy.dialects.postgresql import dialect as postgres_dialect
+from sqlalchemy.engine import URL
 
 
 class DBAPI:
@@ -17,25 +18,27 @@ class ConnectionWrapper:
     c: duckdb.DuckDBPyConnection
     notices: List[str] = field(default_factory=list)
 
-    def cursor(self):
+    def cursor(self) -> "ConnectionWrapper":
         return self
 
-    def fetchmany(self, size=None):
+    def fetchmany(self, size: int = None) -> List:
         # TODO: remove this once duckdb supports fetchmany natively
         return self.c.fetch_df_chunk().values.tolist()
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         return getattr(self.c, name)
 
     @property
-    def connection(self):
+    def connection(self) -> "ConnectionWrapper":
         return self
 
-    def close(self):
+    def close(self) -> None:
         # duckdb doesn't support 'soft closes'
         pass
 
-    def execute(self, statement, parameters=None, context=None):
+    def execute(
+        self, statement: str, parameters: Dict = None, context: Any = None
+    ) -> None:
         if parameters is None:
             self.c.execute(statement)
         else:
@@ -47,37 +50,41 @@ class Dialect(postgres_dialect):
     identifier_preparer = None
     # colspecs TODO: remap types to duckdb types
 
-    def connect(self, *args, **kwargs):
+    def connect(self, *args: Any, **kwargs: Any) -> ConnectionWrapper:
         return ConnectionWrapper(duckdb.connect(*args, **kwargs))
 
-    def on_connect(self):
+    def on_connect(self) -> None:
         pass
 
-    def ddl_compiler(self, dialect, ddl, **kwargs):
+    def ddl_compiler(
+        self, dialect: str, ddl: Any, **kwargs: Any
+    ) -> postgres_dialect.ddl_compiler:
         # TODO: enforce no `serial` type
 
         # duckdb doesn't support foreign key constraints (yet)
         ddl.include_foreign_key_constraints = {}
         return postgres_dialect.ddl_compiler(dialect, ddl, **kwargs)
 
-    def do_execute(self, cursor, statement, parameters, context):
+    def do_execute(
+        self, cursor: ConnectionWrapper, statement: str, parameters: Any, context: Any
+    ) -> None:
         cursor.execute(statement, parameters, context)
 
     @staticmethod
-    def dbapi():
+    def dbapi() -> Type[DBAPI]:
         return DBAPI
 
-    def create_connect_args(self, u):
+    def create_connect_args(self, u: URL) -> Tuple[Tuple, Dict]:
         return (), {"database": u.render_as_string(hide_password=False).split("///")[1]}
 
-    def initialize(self, connection):
+    def initialize(self, connection: ConnectionWrapper) -> None:
         pass
 
-    def do_rollback(self, connection):
+    def do_rollback(self, connection: ConnectionWrapper) -> None:
         pass
 
     @classmethod
-    def get_dialect_cls(cls, u):
+    def get_dialect_cls(cls, u: str) -> Type["Dialect"]:
         return cls
 
 

duckdb_engine/tests/test_basic.py

@@ -4,13 +4,14 @@
 from hypothesis.strategies import text
 from pytest import fixture
 from sqlalchemy import Column, ForeignKey, Integer, Sequence, String, create_engine
+from sqlalchemy.engine import Engine
 from sqlalchemy.engine.url import registry
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import RelationshipProperty, relationship, sessionmaker
+from sqlalchemy.orm import RelationshipProperty, Session, relationship, sessionmaker
 
 
 @fixture
-def engine():
+def engine() -> Engine:
     registry.register("duckdb", "duckdb_engine", "Dialect")
 
     eng = create_engine("duckdb:///:memory:")
@@ -41,16 +42,11 @@ class Owner(Base):  # type: ignore
 
 
 @fixture
-def Session(engine):
-    return sessionmaker(bind=engine)
+def session(engine: Engine) -> Session:
+    return sessionmaker(bind=engine)()
 
 
-@fixture
-def session(Session):
-    return Session()
-
-
-def test_basic(session):
+def test_basic(session: Session) -> None:
     session.add(FakeModel(name="Frank"))
     session.commit()
 
@@ -59,7 +55,7 @@ def test_basic(session):
     assert frank.name == "Frank"
 
 
-def test_foreign(session):
+def test_foreign(session: Session) -> None:
     model = FakeModel(name="Walter")
     session.add(model)
     session.add(Owner(owned=model))
@@ -71,7 +67,7 @@ def test_foreign(session):
 
 
 @given(text())
-def test_simple_string(s):
+def test_simple_string(s: str) -> None:
     assume("\x00" not in s)
     eng = create_engine("duckdb:///:memory:")
     Base.metadata.create_all(eng)

duckdb_engine/tests/test_pandas.py

@@ -53,7 +53,7 @@ def test_to_sql(
     if_exists: str,
     method: Optional[str],
     index: bool = False,
-):
+) -> None:
     eng = create_engine("duckdb:///:memory:")
     try:
         sample_df.to_sql(
@@ -71,7 +71,7 @@ def test_to_sql(
 @mark.parametrize(params_strings["read_sql"], params["read_sql"])
 def test_read_sql(
     chunksize: Optional[int],
-):
+) -> None:
     eng = create_engine("duckdb:///:memory:")
     sample_df.to_sql(name="test_read", con=eng, if_exists="replace")
     query = "SELECT * FROM test_read"

pyproject.toml

@@ -28,6 +28,13 @@ addopts = "--hypothesis-show-statistics"
 
 [tool.mypy]
 ignore_missing_imports = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+warn_redundant_casts = true
+warn_unused_ignores = true
 
 [build-system]
 requires = ["poetry_core>=1.0.0"]