refactor: Add ruff rules, improve type annotations, improve ci performance

.github/workflows/docbuild.yml

@@ -7,10 +7,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
-    - name: Set up Python 3.10
+    - name: Set up Python 3.12
       uses: actions/setup-python@v4
       with:
-        python-version: "3.10"
+        python-version: "3.12"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

altair/_magics.py

@@ -45,22 +45,22 @@ def _prepare_data(data, data_transformers):
     elif isinstance(data, str):
         return {"url": data}
     else:
-        warnings.warn("data of type {} not recognized".format(type(data)), stacklevel=1)
+        warnings.warn(f"data of type {type(data)} not recognized", stacklevel=1)
         return data
 
 
 def _get_variable(name):
     """Get a variable from the notebook namespace."""
     ip = IPython.get_ipython()
     if ip is None:
-        raise ValueError(
+        msg = (
             "Magic command must be run within an IPython "
             "environment, in which get_ipython() is defined."
         )
+        raise ValueError(msg)
     if name not in ip.user_ns:
-        raise NameError(
-            "argument '{}' does not match the name of any defined variable".format(name)
-        )
+        msg = f"argument '{name}' does not match the name of any defined variable"
+        raise NameError(msg)
     return ip.user_ns[name]
 
 
@@ -95,10 +95,11 @@ def vegalite(line, cell):
         try:
             spec = json.loads(cell)
         except json.JSONDecodeError as err:
-            raise ValueError(
+            msg = (
                 "%%vegalite: spec is not valid JSON. "
                 "Install pyyaml to parse spec as yaml"
-            ) from err
+            )
+            raise ValueError(msg) from err
     else:
         spec = yaml.load(cell, Loader=yaml.SafeLoader)
 

altair/expr/consts.py

@@ -1,4 +1,4 @@
-from typing import Dict
+from __future__ import annotations
 
 from .core import ConstExpression
 
@@ -15,7 +15,7 @@
     "PI": "the transcendental number pi (alias to Math.PI)",
 }
 
-NAME_MAP: Dict[str, str] = {}
+NAME_MAP: dict[str, str] = {}
 
 
 def _populate_namespace():

altair/expr/core.py

@@ -1,29 +1,31 @@
+from __future__ import annotations
+from typing import Any
 from ..utils import SchemaBase
 
 
 class DatumType:
     """An object to assist in building Vega-Lite Expressions"""
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "datum"
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr) -> GetAttrExpression:
         if attr.startswith("__") and attr.endswith("__"):
             raise AttributeError(attr)
         return GetAttrExpression("datum", attr)
 
-    def __getitem__(self, attr):
+    def __getitem__(self, attr) -> GetItemExpression:
         return GetItemExpression("datum", attr)
 
-    def __call__(self, datum, **kwargs):
+    def __call__(self, datum, **kwargs) -> dict[str, Any]:
         """Specify a datum for use in an encoding"""
         return dict(datum=datum, **kwargs)
 
 
 datum = DatumType()
 
 
-def _js_repr(val):
+def _js_repr(val) -> str:
     """Return a javascript-safe string representation of val"""
     if val is True:
         return "true"
@@ -39,10 +41,10 @@ def _js_repr(val):
 
 # Designed to work with Expression and VariableParameter
 class OperatorMixin:
-    def _to_expr(self):
+    def _to_expr(self) -> str:
         return repr(self)
 
-    def _from_expr(self, expr):
+    def _from_expr(self, expr) -> Any:
         return expr
 
     def __add__(self, other):
@@ -173,7 +175,7 @@ class Expression(OperatorMixin, SchemaBase):
     def to_dict(self, *args, **kwargs):
         return repr(self)
 
-    def __setattr__(self, attr, val):
+    def __setattr__(self, attr, val) -> None:
         # We don't need the setattr magic defined in SchemaBase
         return object.__setattr__(self, attr, val)
 
@@ -183,52 +185,50 @@ def __getitem__(self, val):
 
 
 class UnaryExpression(Expression):
-    def __init__(self, op, val):
-        super(UnaryExpression, self).__init__(op=op, val=val)
+    def __init__(self, op, val) -> None:
+        super().__init__(op=op, val=val)
 
     def __repr__(self):
-        return "({op}{val})".format(op=self.op, val=_js_repr(self.val))
+        return f"({self.op}{_js_repr(self.val)})"
 
 
 class BinaryExpression(Expression):
-    def __init__(self, op, lhs, rhs):
-        super(BinaryExpression, self).__init__(op=op, lhs=lhs, rhs=rhs)
+    def __init__(self, op, lhs, rhs) -> None:
+        super().__init__(op=op, lhs=lhs, rhs=rhs)
 
     def __repr__(self):
-        return "({lhs} {op} {rhs})".format(
-            op=self.op, lhs=_js_repr(self.lhs), rhs=_js_repr(self.rhs)
-        )
+        return f"({_js_repr(self.lhs)} {self.op} {_js_repr(self.rhs)})"
 
 
 class FunctionExpression(Expression):
-    def __init__(self, name, args):
-        super(FunctionExpression, self).__init__(name=name, args=args)
+    def __init__(self, name, args) -> None:
+        super().__init__(name=name, args=args)
 
     def __repr__(self):
         args = ",".join(_js_repr(arg) for arg in self.args)
-        return "{name}({args})".format(name=self.name, args=args)
+        return f"{self.name}({args})"
 
 
 class ConstExpression(Expression):
-    def __init__(self, name, doc):
-        self.__doc__ = """{}: {}""".format(name, doc)
-        super(ConstExpression, self).__init__(name=name, doc=doc)
+    def __init__(self, name, doc) -> None:
+        self.__doc__ = f"""{name}: {doc}"""
+        super().__init__(name=name, doc=doc)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self.name)
 
 
 class GetAttrExpression(Expression):
-    def __init__(self, group, name):
-        super(GetAttrExpression, self).__init__(group=group, name=name)
+    def __init__(self, group, name) -> None:
+        super().__init__(group=group, name=name)
 
     def __repr__(self):
-        return "{}.{}".format(self.group, self.name)
+        return f"{self.group}.{self.name}"
 
 
 class GetItemExpression(Expression):
-    def __init__(self, group, name):
-        super(GetItemExpression, self).__init__(group=group, name=name)
+    def __init__(self, group, name) -> None:
+        super().__init__(group=group, name=name)
 
-    def __repr__(self):
-        return "{}[{!r}]".format(self.group, self.name)
+    def __repr__(self) -> str:
+        return f"{self.group}[{self.name!r}]"

altair/expr/funcs.py

@@ -1,5 +1,10 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
 from .core import FunctionExpression
 
+if TYPE_CHECKING:
+    from typing import Iterator
+
 
 FUNCTION_LISTING = {
     "isArray": r"Returns true if _value_ is an array, false otherwise.",
@@ -169,19 +174,19 @@
 
 
 class ExprFunc:
-    def __init__(self, name, doc):
+    def __init__(self, name, doc) -> None:
         self.name = name
         self.doc = doc
-        self.__doc__ = """{}(*args)\n    {}""".format(name, doc)
+        self.__doc__ = f"""{name}(*args)\n    {doc}"""
 
-    def __call__(self, *args):
+    def __call__(self, *args) -> FunctionExpression:
         return FunctionExpression(self.name, args)
 
-    def __repr__(self):
-        return "<function expr.{}(*args)>".format(self.name)
+    def __repr__(self) -> str:
+        return f"<function expr.{self.name}(*args)>"
 
 
-def _populate_namespace():
+def _populate_namespace() -> Iterator[str]:
     globals_ = globals()
     for name, doc in FUNCTION_LISTING.items():
         py_name = NAME_MAP.get(name, name)

altair/jupyter/__init__.py

@@ -7,14 +7,15 @@
     # when anywidget is not installed
     class JupyterChart:
         def __init__(self, *args, **kwargs):
-            raise ImportError(
+            msg = (
                 "The Altair JupyterChart requires the anywidget \n"
                 "Python package which may be installed using pip with\n"
                 "    pip install anywidget\n"
                 "or using conda with\n"
                 "    conda install -c conda-forge anywidget\n"
                 "Afterwards, you will need to restart your Python kernel."
             )
+            raise ImportError(msg)
 
 else:
     from .jupyter_chart import JupyterChart  # noqa: F401

altair/jupyter/jupyter_chart.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
 import json
 import anywidget
 import traitlets
 import pathlib
-from typing import Any, Set, Optional
+from typing import Any
 
 import altair as alt
 from altair.utils._vegafusion_data import (
@@ -61,7 +62,8 @@ def __init__(self, trait_values):
             elif isinstance(value, IntervalSelection):
                 traitlet_type = traitlets.Instance(IntervalSelection)
             else:
-                raise ValueError(f"Unexpected selection type: {type(value)}")
+                msg = f"Unexpected selection type: {type(value)}"
+                raise ValueError(msg)
 
             # Add the new trait.
             self.add_traits(**{key: traitlet_type})
@@ -82,10 +84,11 @@ def _make_read_only(self, change):
         """
         if change["name"] in self.traits() and change["old"] != change["new"]:
             self._set_value(change["name"], change["old"])
-        raise ValueError(
+        msg = (
             "Selections may not be set from Python.\n"
             f"Attempted to set select: {change['name']}"
         )
+        raise ValueError(msg)
 
     def _set_value(self, key, value):
         self.unobserve(self._make_read_only, names=key)
@@ -185,7 +188,7 @@ def __init__(
         debounce_wait: int = 10,
         max_wait: bool = True,
         debug: bool = False,
-        embed_options: Optional[dict] = None,
+        embed_options: dict | None = None,
         **kwargs: Any,
     ):
         """
@@ -278,7 +281,8 @@ def _on_change_chart(self, change):
                             name=clean_name, value={}, store=[]
                         )
                     else:
-                        raise ValueError(f"Unexpected selection type {select.type}")
+                        msg = f"Unexpected selection type {select.type}"
+                        raise ValueError(msg)
                     selection_watches.append(clean_name)
                     initial_vl_selections[clean_name] = {"value": None, "store": []}
                 else:
@@ -384,7 +388,7 @@ def _on_change_selections(self, change):
                 )
 
 
-def collect_transform_params(chart: TopLevelSpec) -> Set[str]:
+def collect_transform_params(chart: TopLevelSpec) -> set[str]:
     """
     Collect the names of params that are defined by transforms
 

altair/utils/__init__.py

@@ -16,17 +16,17 @@
 
 
 __all__ = (
-    "infer_vegalite_type",
+    "AltairDeprecationWarning",
+    "PluginRegistry",
+    "SchemaBase",
+    "Undefined",
+    "display_traceback",
     "infer_encoding_types",
-    "sanitize_dataframe",
+    "infer_vegalite_type",
+    "parse_shorthand",
     "sanitize_arrow_table",
+    "sanitize_dataframe",
     "spec_to_html",
-    "parse_shorthand",
-    "use_signature",
     "update_nested",
-    "display_traceback",
-    "AltairDeprecationWarning",
-    "SchemaBase",
-    "Undefined",
-    "PluginRegistry",
+    "use_signature",
 )