BLD: Add disallow_incomplete_defs flag to mypy

Author: Zach Banks

databento/common/bento.py

@@ -1,7 +1,7 @@
 import datetime as dt
 import io
 import os.path
-from typing import Any, BinaryIO, Callable, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -13,6 +13,10 @@
 from databento.common.symbology import ProductIdMappingInterval
 
 
+if TYPE_CHECKING:
+    from databento.historical.client import Historical
+
+
 class Bento:
     """The abstract base class for all Bento I/O classes."""
 
@@ -590,7 +594,7 @@ def to_json(self, path: str) -> None:
         """
         self.to_df().to_json(path, orient="records", lines=True)
 
-    def request_symbology(self, client) -> Dict[str, Any]:
+    def request_symbology(self, client: "Historical") -> Dict[str, Any]:
         """
         Request symbology resolution based on the metadata properties.
 
@@ -622,7 +626,7 @@ def request_symbology(self, client) -> Dict[str, Any]:
 
     def request_full_definitions(
         self,
-        client,
+        client: "Historical",
         path: Optional[str] = None,
     ) -> "Bento":
         """

databento/common/logging.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import sys
+from typing import Optional
 
 import databento
 
@@ -14,7 +15,7 @@
 _ERROR = "ERROR"
 
 
-def _console_log_level():
+def _console_log_level() -> Optional[str]:
     if databento.log:
         databento.log = databento.log.upper()
 
@@ -26,23 +27,23 @@ def _console_log_level():
         return None
 
 
-def log_debug(msg: str):
+def log_debug(msg: str) -> None:
     """Log the given message with DEBUG level."""
     log_level = _console_log_level()
     if log_level == [_DEBUG, _INFO, _ERROR]:
         print(f"DEBUG: {msg}", file=sys.stderr)
     logger.debug(msg)
 
 
-def log_info(msg: str):
+def log_info(msg: str) -> None:
     """Log the given message with INFO level."""
     log_level = _console_log_level()
     if log_level in [_INFO, _ERROR]:
         print(f"INFO: {msg}", file=sys.stderr)
     logger.info(msg)
 
 
-def log_error(msg: str):
+def log_error(msg: str) -> None:
     """Log the given message with ERROR level."""
     log_level = _console_log_level()
     if log_level in [_ERROR]:

databento/historical/api/timeseries.py

@@ -249,7 +249,10 @@ def _is_large_data_size_schema(schema: Schema) -> bool:
     return schema in (Schema.MBO, Schema.MBP_10)
 
 
-def _is_greater_than_one_day(start, end) -> bool:
+def _is_greater_than_one_day(
+    start: Optional[Union[pd.Timestamp, date, str, int]],
+    end: Optional[Union[pd.Timestamp, date, str, int]],
+) -> bool:
     if start is None or end is None:
         return True
 

tests/test_common_validation.py

@@ -1,3 +1,6 @@
+from enum import Enum
+from typing import Any, Type, Union
+
 import pytest
 from databento.common.enums import Compression, Encoding
 from databento.common.validation import validate_enum, validate_maybe_enum
@@ -13,9 +16,9 @@ class TestValidation:
     )
     def test_validate_enum_given_wrong_types_raises_type_error(
         self,
-        value,
-        enum,
-        param,
+        value: Any,
+        enum: Type[Enum],
+        param: str,
     ) -> None:
         # Arrange, Act, Assert
         with pytest.raises(TypeError):
@@ -36,10 +39,10 @@ def test_validate_enum_given_invalid_value_raises_value_error(self) -> None:
     )
     def test_validate_enum_given_valid_value_returns_expected_output(
         self,
-        value,
-        enum,
-        param,
-        expected,
+        value: Union[str, Enum],
+        enum: Type[Enum],
+        param: str,
+        expected: Union[str, Enum],
     ) -> None:
         # Arrange, Act, Assert
         assert validate_enum(value, enum, "param") == expected

tests/test_historical_batch.py

@@ -3,6 +3,7 @@
 import databento as db
 import pytest
 import requests
+from pytest_mock import MockerFixture
 
 
 class TestHistoricalBatch:
@@ -49,7 +50,9 @@ def test_batch_submit_job_given_invalid_stype_in_raises_error(self) -> None:
             )
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_batch_submit_job_sends_expected_request(self, mocker) -> None:
+    def test_batch_submit_job_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.post")
 
@@ -98,7 +101,9 @@ def test_batch_submit_job_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_batch_list_jobs_sends_expected_request(self, mocker) -> None:
+    def test_batch_list_jobs_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 

tests/test_historical_bento.py

@@ -2,7 +2,7 @@
 import os
 import sys
 from pathlib import Path
-from typing import Union
+from typing import List, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -201,7 +201,7 @@ def test_replay_with_stub_data_record_passes_to_callback(self) -> None:
         stub_data = get_test_data(schema=Schema.MBO)
         data = MemoryBento(initial_bytes=stub_data)
 
-        handler: list[tuple[Union[int, bytes], ...]] = []
+        handler: List[Tuple[Union[int, bytes], ...]] = []
 
         # Act
         data.replay(callback=handler.append)
@@ -227,7 +227,9 @@ def test_replay_with_stub_data_record_passes_to_callback(self) -> None:
             )
         ],
     )
-    def test_to_df_across_schemas_returns_identical_dimension_dfs(self, schema) -> None:
+    def test_to_df_across_schemas_returns_identical_dimension_dfs(
+        self, schema: Schema
+    ) -> None:
         # Arrange
         stub_data = get_test_data(schema=schema)
         data = MemoryBento(initial_bytes=stub_data)
@@ -334,8 +336,8 @@ def test_to_df_with_pretty_ts_converts_timestamps_as_expected(self) -> None:
     )
     def test_to_df_with_pretty_px_with_various_schemas_converts_prices_as_expected(
         self,
-        schema,
-        columns,
+        schema: Schema,
+        columns: List[str],
     ) -> None:
         # Arrange
         stub_data = get_test_data(schema=schema)
@@ -366,9 +368,9 @@ def test_to_df_with_pretty_px_with_various_schemas_converts_prices_as_expected(
     )
     def test_from_file_given_various_paths_returns_expected_metadata(
         self,
-        expected_schema,
-        expected_encoding,
-        expected_compression,
+        expected_schema: Schema,
+        expected_encoding: Encoding,
+        expected_compression: Compression,
     ) -> None:
         # Arrange, Act
         path = get_test_data_path(schema=expected_schema)

tests/test_historical_client.py

@@ -1,10 +1,12 @@
 import sys
+from typing import Union
 
 import databento as db
 import pytest
 import requests
 from databento import FileBento, Historical
 from databento.common.enums import HistoricalGateway, Schema
+from pytest_mock import MockerFixture
 from tests.fixtures import get_test_data_path
 
 
@@ -37,8 +39,8 @@ def test_default_host_returns_expected(self) -> None:
     )
     def test_gateway_nearest_and_bo1_map_to_hist_databento(
         self,
-        gateway,
-        expected,
+        gateway: Union[HistoricalGateway, str],
+        expected: str,
     ) -> None:
         # Arrange, Act
         client = db.Historical(key="DUMMY_API_KEY", gateway=gateway)
@@ -57,7 +59,9 @@ def test_custom_gateway_returns_expected(self) -> None:
         assert client.gateway == ny4_gateway
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_re_request_symbology_makes_expected_request(self, mocker) -> None:
+    def test_re_request_symbology_makes_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -93,7 +97,9 @@ def test_re_request_symbology_makes_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_request_full_definitions_expected_request(self, mocker) -> None:
+    def test_request_full_definitions_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 

tests/test_historical_metadata.py

@@ -1,9 +1,11 @@
 import sys
+from typing import Union
 
 import databento as db
 import pytest
 import requests
 from databento.common.enums import Dataset, FeedMode, Schema
+from pytest_mock import MockerFixture
 
 
 class TestHistoricalMetadata:
@@ -12,7 +14,9 @@ def setup(self) -> None:
         self.client = db.Historical(key=key)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_publishers_sends_expected_request(self, mocker) -> None:
+    def test_list_publishers_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -34,7 +38,7 @@ def test_list_publishers_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_datasets_sends_expected_request(self, mocker) -> None:
+    def test_list_datasets_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -61,7 +65,7 @@ def test_list_datasets_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_schemas_sends_expected_request(self, mocker) -> None:
+    def test_list_schemas_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -89,7 +93,7 @@ def test_list_schemas_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_fields_sends_expected_request(self, mocker) -> None:
+    def test_list_fields_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -117,7 +121,7 @@ def test_list_fields_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_encodings_sends_expected_request(self, mocker) -> None:
+    def test_list_encodings_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -139,7 +143,9 @@ def test_list_encodings_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_list_compressions_sends_expected_request(self, mocker) -> None:
+    def test_list_compressions_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -169,7 +175,11 @@ def test_list_compressions_sends_expected_request(self, mocker) -> None:
         ],
     )
     def test_list_unit_price_sends_expected_request(
-        self, dataset, schema, mode, mocker
+        self,
+        dataset: Union[str, Dataset],
+        schema: Union[str, Schema],
+        mode: Union[str, FeedMode],
+        mocker: MockerFixture,
     ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
@@ -201,7 +211,7 @@ def test_list_unit_price_sends_expected_request(
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_get_shape_sends_expected_request(self, mocker) -> None:
+    def test_get_shape_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -240,7 +250,9 @@ def test_get_shape_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_get_billable_size_sends_expected_request(self, mocker) -> None:
+    def test_get_billable_size_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -279,7 +291,7 @@ def test_get_billable_size_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_get_cost_sends_expected_request(self, mocker) -> None:
+    def test_get_cost_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 

tests/test_historical_timeseries.py

@@ -3,6 +3,7 @@
 import databento as db
 import pytest
 import requests
+from pytest_mock import MockerFixture
 
 
 class TestHistoricalTimeSeries:
@@ -46,7 +47,7 @@ def test_stream_given_invalid_stype_out_raises_error(self) -> None:
             )
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_stream_sends_expected_request(self, mocker) -> None:
+    def test_stream_sends_expected_request(self, mocker: MockerFixture) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")
 
@@ -84,7 +85,9 @@ def test_stream_sends_expected_request(self, mocker) -> None:
         assert isinstance(call["auth"], requests.auth.HTTPBasicAuth)
 
     @pytest.mark.skipif(sys.version_info < (3, 8), reason="incompatible mocking")
-    def test_stream_with_limit_sends_expected_request(self, mocker) -> None:
+    def test_stream_with_limit_sends_expected_request(
+        self, mocker: MockerFixture
+    ) -> None:
         # Arrange
         mocked_get = mocker.patch("requests.get")