Merge pull request #53 from yassun7010/fix_ci

fix: ci.

Author: ya7010

.github/workflows/test-suite.yml

@@ -28,6 +28,9 @@ jobs:
           - turu-snowflake
           - turu-bigquery
           - .
+        install-flags:
+          - ""
+          - "--all-extras"
     defaults:
       run:
         working-directory: ${{ matrix.package }}
@@ -44,7 +47,7 @@ jobs:
           poetry --version
       - name: Poetry Install Dependencies
         run: |
-          poetry install --no-interaction --all-extras
+          poetry install --no-interaction ${{ matrix.install-flags }}
       - name: Lint
         run: |
           poetry run task format --diff

turu-core/src/turu/core/cursor.py

@@ -10,6 +10,7 @@
     Type,
     TypeVar,
     Union,
+    cast,
 )
 
 from turu.core.exception import TuruRowTypeMismatchError
@@ -140,13 +141,17 @@ def map_row(row_type: Optional[Type[GenericRowType]], row: Any) -> GenericRowTyp
             }
         )  # type: ignore
 
-    if issubclass(row_type, tuple):
+    elif issubclass(row_type, tuple):
         return row_type._make(row)  # type: ignore
 
-    if USE_PYDANTIC:
-        if issubclass(row_type, PydanticModel):
-            return row_type(
-                **{key: data for key, data in zip(row_type.model_fields.keys(), row)}
-            )
+    elif USE_PYDANTIC and issubclass(row_type, PydanticModel):
+        return row_type(
+            **{
+                key: data
+                for key, data in zip(
+                    cast(PydanticModel, row_type).model_fields.keys(), row
+                )
+            }
+        )  # type: ignore
 
     raise TuruRowTypeMismatchError(row_type, row.__class__)

turu-core/src/turu/core/features.py

@@ -1,14 +1,17 @@
+from typing_extensions import TypeAlias
+
+
 class _NotSupportFeature:
     pass
 
 
 try:
-    import pydantic  # noqa: F401
+    import pydantic  # type: ignore[import]
 
     USE_PYDANTIC = True
-    PydanticModel = pydantic.BaseModel
+    PydanticModel: TypeAlias = pydantic.BaseModel  # type: ignore
 
 except ImportError:
     USE_PYDANTIC = False
 
-    PydanticModel = _NotSupportFeature
+    PydanticModel: TypeAlias = _NotSupportFeature  # type: ignore

turu-core/tests/turu/core/test_mock.py

@@ -3,7 +3,7 @@
 
 import pytest
 import turu.core.mock
-from pydantic import BaseModel
+from turu.core.features import USE_PYDANTIC
 from turu.core.mock.exception import (
     TuruMockStoreDataNotFoundError,
     TuruMockUnexpectedFetchError,
@@ -21,8 +21,16 @@ class RowDataclass:
     id: int
 
 
-class RowPydantic(BaseModel):
-    id: int
+if USE_PYDANTIC:
+    from pydantic import BaseModel  # type: ignore[import]
+
+    class RowPydantic(BaseModel):
+        id: int
+
+    ROW_TYPE_LIST = [RowNamedTuple, RowDataclass, RowPydantic]
+
+else:
+    ROW_TYPE_LIST = [RowNamedTuple, RowDataclass]
 
 
 class TestTuruMock:
@@ -57,10 +65,10 @@ def test_execute(self, mock_connection: turu.core.mock.MockConnection):
     def test_mock_execute_map_fetchone(
         self, mock_connection: turu.core.mock.MockConnection, rowsize: int
     ):
-        expected = [RowPydantic(id=i) for i in range(rowsize)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [RowDataclass(id=i) for i in range(rowsize)]
+        mock_connection.inject_response(RowDataclass, expected)
 
-        cursor = mock_connection.cursor().execute_map(RowPydantic, "SELECT 1")
+        cursor = mock_connection.cursor().execute_map(RowDataclass, "SELECT 1")
         for i in range(rowsize):
             assert cursor.fetchone() == expected[i]
 
@@ -72,10 +80,10 @@ def test_mock_execute_map_fetchmany(
         mock_connection: turu.core.mock.MockConnection,
         rowsize: int,
     ):
-        expected = [RowPydantic(id=i) for i in range(rowsize)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [RowDataclass(id=i) for i in range(rowsize)]
+        mock_connection.inject_response(RowDataclass, expected)
 
-        cursor = mock_connection.cursor().execute_map(RowPydantic, "SELECT 1")
+        cursor = mock_connection.cursor().execute_map(RowDataclass, "SELECT 1")
 
         assert list(cursor.fetchmany(rowsize)) == expected
         assert cursor.fetchone() is None
@@ -84,17 +92,15 @@ def test_mock_execute_map_fetchmany(
     def test_mock_execute_map_fetchall(
         self, mock_connection: turu.core.mock.MockConnection, rowsize: int
     ):
-        expected = [RowPydantic(id=i) for i in range(rowsize)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [RowDataclass(id=i) for i in range(rowsize)]
+        mock_connection.inject_response(RowDataclass, expected)
 
-        cursor = mock_connection.cursor().execute_map(RowPydantic, "SELECT 1")
+        cursor = mock_connection.cursor().execute_map(RowDataclass, "SELECT 1")
 
         assert list(cursor.fetchall()) == expected
         assert cursor.fetchall() == []
 
-    @pytest.mark.parametrize(
-        "GenericRowType", [RowNamedTuple, RowDataclass, RowPydantic]
-    )
+    @pytest.mark.parametrize("GenericRowType", ROW_TYPE_LIST)
     def test_execute_map_by_rowtype(
         self, GenericRowType: Any, mock_connection: turu.core.mock.MockConnection
     ):
@@ -109,30 +115,30 @@ def test_execute_map_multi_call(
         self, mock_connection: turu.core.mock.MockConnection
     ):
         expected_array = [
-            [RowPydantic(id=1), RowPydantic(id=2), RowPydantic(id=3)],
-            [RowPydantic(id=4), RowPydantic(id=5), RowPydantic(id=6)],
-            [RowPydantic(id=7), RowPydantic(id=8), RowPydantic(id=9)],
+            [RowDataclass(id=1), RowDataclass(id=2), RowDataclass(id=3)],
+            [RowDataclass(id=4), RowDataclass(id=5), RowDataclass(id=6)],
+            [RowDataclass(id=7), RowDataclass(id=8), RowDataclass(id=9)],
         ]
 
         for expected in expected_array:
-            mock_connection.inject_response(RowPydantic, expected)
+            mock_connection.inject_response(RowDataclass, expected)
 
         cursor = mock_connection.cursor()
         for expected in expected_array:
-            assert cursor.execute_map(RowPydantic, "SELECT 1").fetchall() == expected
+            assert cursor.execute_map(RowDataclass, "SELECT 1").fetchall() == expected
 
         assert cursor.fetchone() is None
 
     @pytest.mark.parametrize("execition_time", range(5))
     def test_execute_map_each_inject_and_execute(
         self, execition_time: int, mock_connection: turu.core.mock.MockConnection
     ):
-        expected = [RowPydantic(id=i) for i in range(3)]
+        expected = [RowDataclass(id=i) for i in range(3)]
         for _ in range(execition_time):
-            mock_connection.inject_response(RowPydantic, expected)
+            mock_connection.inject_response(RowDataclass, expected)
             cursor = mock_connection.cursor()
 
-            assert cursor.execute_map(RowPydantic, "SELECT 1").fetchall() == expected
+            assert cursor.execute_map(RowDataclass, "SELECT 1").fetchall() == expected
             assert cursor.fetchone() is None
 
     def test_executemany(self, mock_connection: turu.core.mock.MockConnection):
@@ -141,42 +147,45 @@ def test_executemany(self, mock_connection: turu.core.mock.MockConnection):
             assert cursor.fetchall() == [(1,), (1,)]
 
     def test_executemany_map(self, mock_connection: turu.core.mock.MockConnection):
-        expected = [RowPydantic(id=i) for i in range(3)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [RowDataclass(id=i) for i in range(3)]
+        mock_connection.inject_response(RowDataclass, expected)
 
         with mock_connection.executemany_map(
-            RowPydantic, "SELECT 1", [(), ()]
+            RowDataclass, "SELECT 1", [(), ()]
         ) as cursor:
             assert cursor.fetchall() == expected
             assert cursor.fetchone() is None
 
     def test_multi_injection(self, mock_connection: turu.core.mock.MockConnection):
-        expected = [RowPydantic(id=i) for i in range(3)]
+        expected = [RowDataclass(id=i) for i in range(3)]
         (
             mock_connection.chain()
-            .inject_response(RowPydantic, expected)
-            .inject_response(RowPydantic, expected)
-            .inject_response(RowPydantic, expected)
-            .inject_response(RowPydantic, expected)
+            .inject_response(RowDataclass, expected)
+            .inject_response(RowDataclass, expected)
+            .inject_response(RowDataclass, expected)
+            .inject_response(RowDataclass, expected)
         )
 
         cursor = mock_connection.cursor()
         for _ in range(4):
-            assert cursor.execute_map(RowPydantic, "SELECT 1").fetchall() == expected
+            assert cursor.execute_map(RowDataclass, "SELECT 1").fetchall() == expected
             assert cursor.fetchone() is None
 
     def test_cursor_iterator(self, mock_connection: turu.core.mock.MockConnection):
-        expected = [RowPydantic(id=i) for i in range(3)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [RowDataclass(id=i) for i in range(3)]
+        mock_connection.inject_response(RowDataclass, expected)
 
         for i, row in enumerate(
-            mock_connection.cursor().execute_map(RowPydantic, "SELECT 1")
+            mock_connection.cursor().execute_map(RowDataclass, "SELECT 1")
         ):
             assert row == expected[i]
 
+    @pytest.mark.skipif(not USE_PYDANTIC, reason="pydantic is not found")
     def test_inject_response_from_csv(
         self, mock_connection: turu.core.mock.MockConnection
     ):
+        from pydantic import BaseModel  # type: ignore[import]
+
         class Row(BaseModel):
             id: int
             name: str
@@ -194,16 +203,16 @@ class Row(BaseModel):
         ]
 
     def test_with_statement(self, mock_connection: turu.core.mock.MockConnection):
-        expected = [RowPydantic(id=i) for i in range(3)]
+        expected = [RowDataclass(id=i) for i in range(3)]
 
-        mock_connection.inject_response(RowPydantic, expected)
+        mock_connection.inject_response(RowDataclass, expected)
 
-        with mock_connection.execute_map(RowPydantic, "SELECT 1") as cursor:
+        with mock_connection.execute_map(RowDataclass, "SELECT 1") as cursor:
             assert cursor.fetchall() == expected
             assert cursor.fetchone() is None
 
     def test_inject_execption(self, mock_connection: turu.core.mock.MockConnection):
-        mock_connection.inject_response(RowPydantic, ValueError("test"))
+        mock_connection.inject_response(RowDataclass, ValueError("test"))
 
         with pytest.raises(ValueError):
-            mock_connection.execute_map(RowPydantic, "SELECT 1")
+            mock_connection.execute_map(RowDataclass, "SELECT 1")

turu-core/tests/turu/core/test_record.py

@@ -1,17 +1,18 @@
 import tempfile
+from dataclasses import dataclass
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Literal
 
 import pytest
 import turu.core.mock
-from pydantic import BaseModel
 from turu.core.exception import TuruRowTypeNotSupportedError
 from turu.core.record import RecordCursor, record_to_csv
 from typing_extensions import Never, Self
 
 
-class RowPydantic(BaseModel):
+@dataclass
+class Row:
     id: int
     name: str
 
@@ -63,13 +64,13 @@ def test_record_to_csv_execute_tuple_without_header(
     def test_record_to_csv_execute_map(
         self, mock_connection: turu.core.mock.MockConnection
     ):
-        expected = [RowPydantic(id=i, name=f"name{i}") for i in range(5)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [Row(id=i, name=f"name{i}") for i in range(5)]
+        mock_connection.inject_response(Row, expected)
 
         with tempfile.NamedTemporaryFile() as file:
             with record_to_csv(
                 file.name,
-                mock_connection.execute_map(RowPydantic, "select 1, 'name"),
+                mock_connection.execute_map(Row, "select 1, 'name"),
             ) as cursor:
                 assert cursor.fetchall() == expected
 
@@ -90,13 +91,13 @@ def test_record_to_csv_execute_map(
     def test_record_to_csv_execute_map_without_header_options(
         self, mock_connection: turu.core.mock.MockConnection
     ):
-        expected = [RowPydantic(id=i, name=f"name{i}") for i in range(5)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [Row(id=i, name=f"name{i}") for i in range(5)]
+        mock_connection.inject_response(Row, expected)
 
         with tempfile.NamedTemporaryFile() as file:
             with record_to_csv(
                 file.name,
-                mock_connection.execute_map(RowPydantic, "select 1, 'name"),
+                mock_connection.execute_map(Row, "select 1, 'name"),
                 header=False,
             ) as cursor:
                 assert cursor.fetchall() == expected
@@ -117,13 +118,13 @@ def test_record_to_csv_execute_map_without_header_options(
     def test_record_to_csv_execute_map_with_limit_options(
         self, mock_connection: turu.core.mock.MockConnection
     ):
-        expected = [RowPydantic(id=i, name=f"name{i}") for i in range(5)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [Row(id=i, name=f"name{i}") for i in range(5)]
+        mock_connection.inject_response(Row, expected)
 
         with tempfile.NamedTemporaryFile() as file:
             with record_to_csv(
                 file.name,
-                mock_connection.execute_map(RowPydantic, "select 1, 'name"),
+                mock_connection.execute_map(Row, "select 1, 'name"),
                 limit=3,
             ) as cursor:
                 assert cursor.fetchall() == expected
@@ -146,13 +147,13 @@ def test_record_to_csv_execute_map_with_enable_options(
         mock_connection: turu.core.mock.MockConnection,
         enable: Literal["true", True],
     ):
-        expected = [RowPydantic(id=i, name=f"name{i}") for i in range(5)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [Row(id=i, name=f"name{i}") for i in range(5)]
+        mock_connection.inject_response(Row, expected)
 
         with tempfile.NamedTemporaryFile() as file:
             with record_to_csv(
                 file.name,
-                mock_connection.execute_map(RowPydantic, "select 1, 'name"),
+                mock_connection.execute_map(Row, "select 1, 'name"),
                 enable=enable,
             ) as cursor:
                 assert isinstance(cursor, RecordCursor)
@@ -178,13 +179,13 @@ def test_record_to_csv_execute_map_with_disable_options(
         mock_connection: turu.core.mock.MockConnection,
         enable: Literal["false", False, None],
     ):
-        expected = [RowPydantic(id=i, name=f"name{i}") for i in range(5)]
-        mock_connection.inject_response(RowPydantic, expected)
+        expected = [Row(id=i, name=f"name{i}") for i in range(5)]
+        mock_connection.inject_response(Row, expected)
 
         with tempfile.NamedTemporaryFile() as file:
             with record_to_csv(
                 file.name,
-                mock_connection.execute_map(RowPydantic, "select 1, 'name"),
+                mock_connection.execute_map(Row, "select 1, 'name"),
                 enable=enable,
             ) as cursor:
                 assert not isinstance(cursor, RecordCursor)