Added return type annotations to tests [skip ci]

Author: ankane

pyproject.toml

@@ -46,7 +46,7 @@ files = [
     "tests"
 ]
 strict = true
-disable_error_code = ["unused-ignore", "no-untyped-def"]
+disable_error_code = ["unused-ignore"]
 ignore_missing_imports = true
 disallow_subclassing_any = false
 python_executable = ".venv/bin/python"

tests/test_asyncpg.py

@@ -19,7 +19,7 @@ async def setup_connection(self) -> Connection:
         return conn
 
     @pytest.mark.asyncio
-    async def test_vector(self):
+    async def test_vector(self) -> None:
         conn = await self.setup_connection()
         await conn.execute('DROP TABLE IF EXISTS asyncpg_items')
         await conn.execute('CREATE TABLE asyncpg_items (id bigserial PRIMARY KEY, embedding vector(3))')
@@ -43,7 +43,7 @@ async def test_vector(self):
         await conn.close()
 
     @pytest.mark.asyncio
-    async def test_halfvec(self):
+    async def test_halfvec(self) -> None:
         conn = await self.setup_connection()
         await conn.execute('DROP TABLE IF EXISTS asyncpg_items')
         await conn.execute('CREATE TABLE asyncpg_items (id bigserial PRIMARY KEY, embedding halfvec(3))')
@@ -65,7 +65,7 @@ async def test_halfvec(self):
         await conn.close()
 
     @pytest.mark.asyncio
-    async def test_bit(self):
+    async def test_bit(self) -> None:
         conn = await self.setup_connection()
         await conn.execute('DROP TABLE IF EXISTS asyncpg_items')
         await conn.execute('CREATE TABLE asyncpg_items (id bigserial PRIMARY KEY, embedding bit(3))')
@@ -86,7 +86,7 @@ async def test_bit(self):
         await conn.close()
 
     @pytest.mark.asyncio
-    async def test_sparsevec(self):
+    async def test_sparsevec(self) -> None:
         conn = await self.setup_connection()
         await conn.execute('DROP TABLE IF EXISTS asyncpg_items')
         await conn.execute('CREATE TABLE asyncpg_items (id bigserial PRIMARY KEY, embedding sparsevec(3))')
@@ -106,7 +106,7 @@ async def test_sparsevec(self):
         await conn.close()
 
     @pytest.mark.asyncio
-    async def test_vector_array(self):
+    async def test_vector_array(self) -> None:
         conn = await self.setup_connection()
         await conn.execute('DROP TABLE IF EXISTS asyncpg_items')
         await conn.execute('CREATE TABLE asyncpg_items (id bigserial PRIMARY KEY, embeddings vector[])')
@@ -130,8 +130,8 @@ async def test_vector_array(self):
         await conn.close()
 
     @pytest.mark.asyncio
-    async def test_pool(self):
-        async def init(conn):
+    async def test_pool(self) -> None:
+        async def init(conn) -> None:
             await register_vector(conn)
 
         pool = await asyncpg.create_pool(database='pgvector_python_test', init=init)

tests/test_bit.py

@@ -10,74 +10,74 @@
 
 
 class TestBit:
-    def test_list(self):
+    def test_list(self) -> None:
         assert Bit([True, False, True]).to_list() == [True, False, True]
 
-    def test_list_none(self):
+    def test_list_none(self) -> None:
         with pytest.raises(ValueError) as error:
             Bit([True, None, True])  # type: ignore
         assert str(error.value) == 'expected list[bool]'
 
-    def test_list_int(self):
+    def test_list_int(self) -> None:
         with pytest.raises(ValueError) as error:
             Bit([254, 7, 0])  # type: ignore
         assert str(error.value) == 'expected list[bool]'
 
-    def test_list_list(self):
+    def test_list_list(self) -> None:
         with pytest.raises(ValueError) as error:
             Bit([[True, False], [True, False]])  # type: ignore
         assert str(error.value) == 'expected list[bool]'
 
-    def test_str(self):
+    def test_str(self) -> None:
         assert Bit('101').to_list() == [True, False, True]
 
-    def test_str_two(self):
+    def test_str_two(self) -> None:
         with pytest.raises(ValueError) as error:
             Bit('201')
         assert str(error.value) == 'expected bit string'
 
-    def test_bytes(self):
+    def test_bytes(self) -> None:
         assert Bit(b'\xff\x00\xf0').to_text() == '111111110000000011110000'
         assert Bit(b'\xfe\x07\x00').to_text() == '111111100000011100000000'
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_ndarray(self):
+    def test_ndarray(self) -> None:
         arr = np.array([True, False, True])
         assert Bit(arr).to_list() == [True, False, True]
         assert np.array_equal(Bit(arr).to_numpy(), arr)
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_ndarray_unpackbits(self):
+    def test_ndarray_unpackbits(self) -> None:
         arr = np.unpackbits(np.array([254, 7, 0], dtype=np.uint8))
         assert Bit(arr).to_text() == '111111100000011100000000'
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_ndarray_uint8(self):
+    def test_ndarray_uint8(self) -> None:
         arr = np.array([254, 7, 0], dtype=np.uint8)
         with pytest.raises(ValueError) as error:
             Bit(arr)
         assert str(error.value) == 'expected elements to be boolean'
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_ndarray_uint16(self):
+    def test_ndarray_uint16(self) -> None:
         arr = np.array([254, 7, 0], dtype=np.uint16)
         with pytest.raises(ValueError) as error:
             Bit(arr)  # type: ignore
         assert str(error.value) == 'expected elements to be boolean'
 
-    def test_bool(self):
+    def test_bool(self) -> None:
         with pytest.raises(ValueError) as error:
             Bit(True)  # type: ignore
         assert str(error.value) == 'expected bytes, str, list, or ndarray'
 
-    def test_random(self):
+    def test_random(self) -> None:
         value = ''.join(random.choices(['0', '1'], k=random.randint(1024, 2048)))
         assert Bit(value).to_text() == value
 
-    def test_repr(self):
+    def test_repr(self) -> None:
         assert repr(Bit([True, False, True])) == 'Bit(101)'
         assert str(Bit([True, False, True])) == 'Bit(101)'
 
-    def test_equality(self):
+    def test_equality(self) -> None:
         assert Bit([True, False, True]) == Bit([True, False, True])
         assert Bit([True, False, True]) != Bit([True, False, False])

tests/test_half_vector.py

@@ -10,58 +10,58 @@
 
 
 class TestHalfVector:
-    def test_list(self):
+    def test_list(self) -> None:
         assert HalfVector([1, 2, 3]).to_list() == [1, 2, 3]
 
-    def test_list_empty(self):
+    def test_list_empty(self) -> None:
         assert HalfVector([]).to_list() == []
 
-    def test_list_str(self):
+    def test_list_str(self) -> None:
         with pytest.raises(ValueError) as error:
             HalfVector([1, 'two', 3])  # type: ignore
         assert str(error.value) == 'expected list[float]'
 
-    def test_list_list(self):
+    def test_list_list(self) -> None:
         with pytest.raises(ValueError) as error:
             HalfVector([[1, 2], [3, 4]])  # type: ignore
         assert str(error.value) == 'expected list[float]'
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_ndarray(self):
+    def test_ndarray(self) -> None:
         arr = np.array([1, 2, 3])
         assert HalfVector(arr).to_list() == [1, 2, 3]
         assert HalfVector(arr).to_numpy() is not arr
 
-    def test_int(self):
+    def test_int(self) -> None:
         with pytest.raises(ValueError) as error:
             HalfVector(1)  # type: ignore
         assert str(error.value) == 'expected list or ndarray'
 
-    def test_repr(self):
+    def test_repr(self) -> None:
         assert repr(HalfVector([1, 2, 3])) == 'HalfVector([1.0, 2.0, 3.0])'
         assert str(HalfVector([1, 2, 3])) == 'HalfVector([1.0, 2.0, 3.0])'
 
-    def test_equality(self):
+    def test_equality(self) -> None:
         assert HalfVector([1, 2, 3]) == HalfVector([1, 2, 3])
         assert HalfVector([1, 2, 3]) != HalfVector([1, 2, 4])
 
-    def test_dimensions(self):
+    def test_dimensions(self) -> None:
         assert HalfVector([1, 2, 3]).dimensions() == 3
 
     @pytest.mark.skipif(not NUMPY_AVAILABLE, reason='NumPy required')
-    def test_to_numpy_readonly(self):
+    def test_to_numpy_readonly(self) -> None:
         arr = HalfVector([1, 2, 3]).to_numpy()
         with pytest.raises(ValueError) as error:
             arr[0] = 4
         assert str(error.value) == 'assignment destination is read-only'
 
-    def test_from_text(self):
+    def test_from_text(self) -> None:
         vec = HalfVector.from_text('[1.5,2,3]')
         assert vec.to_list() == [1.5, 2, 3]
         if NUMPY_AVAILABLE:
             assert np.array_equal(vec.to_numpy(), [1.5, 2, 3])
 
-    def test_from_binary(self):
+    def test_from_binary(self) -> None:
         data = pack('>HH3e', 3, 0, 1.5, 2, 3)
         vec = HalfVector.from_binary(data)
         assert vec.to_list() == [1.5, 2, 3]