Type hints: Finish type hints and mark package as typed

CONTRIBUTING.md

@@ -72,7 +72,7 @@ hatch run test
 ```
 
 
-This also runs the [`black`](https://black.readthedocs.io/) code formatter, [`ruff`](https://ruff.rs/) linter and [`mypy`](https://mypy-lang.org/) as type checker.
+This also runs the [`ruff`](https://ruff.rs/) linter and formatter as well as [`mypy`](https://mypy-lang.org/) as type checker.
 
 
 Study the output of any failed tests and try to fix the issues

altair/utils/_vegafusion_data.py

@@ -8,7 +8,7 @@
 
 from altair.utils._importers import import_vegafusion
 from altair.utils.core import _DataFrameLike
-from altair.utils.data import _DataType, _ToValuesReturnType, MaxRowsError
+from altair.utils.data import DataType, ToValuesReturnType, MaxRowsError
 from altair.vegalite.data import default_data_transformer
 
 # Temporary storage for dataframes that have been extracted
@@ -29,8 +29,8 @@ class _ToVegaFusionReturnUrlDict(TypedDict):
 
 @curried.curry
 def vegafusion_data_transformer(
-    data: _DataType, max_rows: int = 100000
-) -> Union[_ToVegaFusionReturnUrlDict, _ToValuesReturnType]:
+    data: DataType, max_rows: int = 100000
+) -> Union[_ToVegaFusionReturnUrlDict, ToValuesReturnType]:
     """VegaFusion Data Transformer"""
     if hasattr(data, "__geo_interface__"):
         # Use default transformer for geo interface objects

altair/utils/core.py

@@ -41,8 +41,8 @@
 if TYPE_CHECKING:
     from pandas.core.interchange.dataframe_protocol import Column as PandasColumn
 
-_V = TypeVar("_V")
-_P = ParamSpec("_P")
+V = TypeVar("V")
+P = ParamSpec("P")
 
 
 class _DataFrameLike(Protocol):
@@ -188,12 +188,12 @@ def __dataframe__(self, *args, **kwargs) -> DfiDataFrame:
 ]
 
 
-_InferredVegaLiteType = Literal["ordinal", "nominal", "quantitative", "temporal"]
+InferredVegaLiteType = Literal["ordinal", "nominal", "quantitative", "temporal"]
 
 
 def infer_vegalite_type(
     data: object,
-) -> Union[_InferredVegaLiteType, Tuple[_InferredVegaLiteType, list]]:
+) -> Union[InferredVegaLiteType, Tuple[InferredVegaLiteType, list]]:
     """
     From an array-like input, infer the correct vega typecode
     ('ordinal', 'nominal', 'quantitative', or 'temporal')
@@ -637,7 +637,7 @@ def parse_shorthand(
 
 def infer_vegalite_type_for_dfi_column(
     column: Union[Column, "PandasColumn"],
-) -> Union[_InferredVegaLiteType, Tuple[_InferredVegaLiteType, list]]:
+) -> Union[InferredVegaLiteType, Tuple[InferredVegaLiteType, list]]:
     from pyarrow.interchange.from_dataframe import column_to_array
 
     try:
@@ -672,10 +672,10 @@ def infer_vegalite_type_for_dfi_column(
         raise ValueError(f"Unexpected DtypeKind: {kind}")
 
 
-def use_signature(Obj: Callable[_P, Any]):
+def use_signature(Obj: Callable[P, Any]):
     """Apply call signature and documentation of Obj to the decorated method"""
 
-    def decorate(f: Callable[..., _V]) -> Callable[_P, _V]:
+    def decorate(f: Callable[..., V]) -> Callable[P, V]:
         # call-signature of f is exposed via __wrapped__.
         # we want it to mimic Obj.__init__
         f.__wrapped__ = Obj.__init__  # type: ignore

altair/utils/data.py

@@ -27,11 +27,11 @@ class _SupportsGeoInterface(Protocol):
     __geo_interface__: MutableMapping
 
 
-_DataType = Union[dict, pd.DataFrame, _SupportsGeoInterface, _DataFrameLike]
-_TDataType = TypeVar("_TDataType", bound=_DataType)
+DataType = Union[dict, pd.DataFrame, _SupportsGeoInterface, _DataFrameLike]
+TDataType = TypeVar("TDataType", bound=DataType)
 
-_VegaLiteDataDict = Dict[str, Union[str, dict, List[dict]]]
-_ToValuesReturnType = Dict[str, Union[dict, List[dict]]]
+VegaLiteDataDict = Dict[str, Union[str, dict, List[dict]]]
+ToValuesReturnType = Dict[str, Union[dict, List[dict]]]
 
 
 # ==============================================================================
@@ -46,7 +46,7 @@ class _SupportsGeoInterface(Protocol):
 # form.
 # ==============================================================================
 class DataTransformerType(Protocol):
-    def __call__(self, data: _DataType, **kwargs) -> _VegaLiteDataDict:
+    def __call__(self, data: DataType, **kwargs) -> VegaLiteDataDict:
         pass
 
 
@@ -70,7 +70,7 @@ class MaxRowsError(Exception):
 
 
 @curried.curry
-def limit_rows(data: _TDataType, max_rows: Optional[int] = 5000) -> _TDataType:
+def limit_rows(data: TDataType, max_rows: Optional[int] = 5000) -> TDataType:
     """Raise MaxRowsError if the data model has more than max_rows.
 
     If max_rows is None, then do not perform any check.
@@ -122,7 +122,7 @@ def raise_max_rows_error():
 
 @curried.curry
 def sample(
-    data: _DataType, n: Optional[int] = None, frac: Optional[float] = None
+    data: DataType, n: Optional[int] = None, frac: Optional[float] = None
 ) -> Optional[Union[pd.DataFrame, Dict[str, Sequence], "pyarrow.lib.Table"]]:
     """Reduce the size of the data model by sampling without replacement."""
     check_data_type(data)
@@ -180,7 +180,7 @@ class _ToCsvReturnUrlDict(TypedDict):
 
 @curried.curry
 def to_json(
-    data: _DataType,
+    data: DataType,
     prefix: str = "altair-data",
     extension: str = "json",
     filename: str = "{prefix}-{hash}.{extension}",
@@ -215,7 +215,7 @@ def to_csv(
 
 
 @curried.curry
-def to_values(data: _DataType) -> _ToValuesReturnType:
+def to_values(data: DataType) -> ToValuesReturnType:
     """Replace a DataFrame by a data model with values."""
     check_data_type(data)
     if hasattr(data, "__geo_interface__"):
@@ -242,7 +242,7 @@ def to_values(data: _DataType) -> _ToValuesReturnType:
         raise ValueError("Unrecognized data type: {}".format(type(data)))
 
 
-def check_data_type(data: _DataType) -> None:
+def check_data_type(data: DataType) -> None:
     if not isinstance(data, (dict, pd.DataFrame)) and not any(
         hasattr(data, attr) for attr in ["__geo_interface__", "__dataframe__"]
     ):
@@ -260,7 +260,7 @@ def _compute_data_hash(data_str: str) -> str:
     return hashlib.md5(data_str.encode()).hexdigest()
 
 
-def _data_to_json_string(data: _DataType) -> str:
+def _data_to_json_string(data: DataType) -> str:
     """Return a JSON string representation of the input data"""
     check_data_type(data)
     if hasattr(data, "__geo_interface__"):

altair/utils/schemapi.py

@@ -44,7 +44,7 @@
 else:
     from typing_extensions import Self
 
-_TSchemaBase = TypeVar("_TSchemaBase", bound="SchemaBase")
+TSchemaBase = TypeVar("TSchemaBase", bound=Type["SchemaBase"])
 
 ValidationErrorList = List[jsonschema.exceptions.ValidationError]
 GroupedValidationErrors = Dict[str, ValidationErrorList]
@@ -733,11 +733,7 @@ def __repr__(self):
         return "Undefined"
 
 
-# In the future Altair may implement a more complete set of type hints.
-# But for now, we'll add an annotation to indicate that the type checker
-# should permit any value passed to a function argument whose default
-# value is Undefined.
-Undefined: Any = UndefinedType()
+Undefined = UndefinedType()
 
 
 class SchemaBase:
@@ -1329,7 +1325,7 @@ def __call__(self, *args, **kwargs):
         return obj
 
 
-def with_property_setters(cls: _TSchemaBase) -> _TSchemaBase:
+def with_property_setters(cls: TSchemaBase) -> TSchemaBase:
     """
     Decorator to add property setters to a Schema class.
     """

altair/vegalite/data.py

@@ -12,14 +12,14 @@
     check_data_type,
 )
 from ..utils.data import DataTransformerRegistry as _DataTransformerRegistry
-from ..utils.data import _DataType, _ToValuesReturnType
+from ..utils.data import DataType, ToValuesReturnType
 from ..utils.plugin_registry import PluginEnabler
 
 
 @curried.curry
 def default_data_transformer(
-    data: _DataType, max_rows: int = 5000
-) -> _ToValuesReturnType:
+    data: DataType, max_rows: int = 5000
+) -> ToValuesReturnType:
     return curried.pipe(data, limit_rows(max_rows=max_rows), to_values)