Type checking with pyright

dp_wizard/app/__init__.py

@@ -1,9 +1,9 @@
 from pathlib import Path
 import logging
 
-from shiny import App, ui, reactive
+from shiny import App, ui, reactive, Inputs, Outputs, Session
 
-from dp_wizard.utils.argparse_helpers import get_cli_info
+from dp_wizard.utils.argparse_helpers import get_cli_info, CLIInfo
 from dp_wizard.app import analysis_panel, dataset_panel, results_panel, feedback_panel
 
 
@@ -26,16 +26,17 @@ def ctrl_c_reminder():  # pragma: no cover
     print("Session ended (Press CTRL+C to quit)")
 
 
-def make_server_from_cli_info(cli_info):
-    def server(input, output, session):  # pragma: no cover
-        csv_path = reactive.value(cli_info.csv_path)
+def make_server_from_cli_info(cli_info: CLIInfo):
+    def server(input: Inputs, output: Outputs, session: Session):  # pragma: no cover
+        cli_csv_path = cli_info.csv_path
+        csv_path = reactive.value("" if cli_csv_path is None else cli_csv_path)
         contributions = reactive.value(cli_info.contributions)
 
         lower_bounds = reactive.value({})
         upper_bounds = reactive.value({})
         bin_counts = reactive.value({})
         weights = reactive.value({})
-        epsilon = reactive.value(1)
+        epsilon = reactive.value(1.0)
 
         dataset_panel.dataset_server(
             input,

dp_wizard/app/analysis_panel.py

@@ -1,6 +1,7 @@
 from math import pow
+from typing import Iterable, Any
 
-from shiny import ui, reactive, render, req
+from shiny import ui, reactive, render, req, Inputs, Outputs, Session
 
 from dp_wizard.app.components.inputs import log_slider
 from dp_wizard.app.components.column_module import column_ui, column_server
@@ -39,7 +40,9 @@ def analysis_ui():
     )
 
 
-def _cleanup_reactive_dict(reactive_dict, keys_to_keep):  # pragma: no cover
+def _cleanup_reactive_dict(
+    reactive_dict: reactive.Value[dict[str, Any]], keys_to_keep: Iterable[str]
+):  # pragma: no cover
     reactive_dict_copy = {**reactive_dict()}
     keys_to_del = set(reactive_dict_copy.keys()) - set(keys_to_keep)
     for key in keys_to_del:
@@ -48,25 +51,25 @@ def _cleanup_reactive_dict(reactive_dict, keys_to_keep):  # pragma: no cover
 
 
 def analysis_server(
-    input,
-    output,
-    session,
-    csv_path,
-    contributions,
-    is_demo,
-    lower_bounds,
-    upper_bounds,
-    bin_counts,
-    weights,
-    epsilon,
+    input: Inputs,
+    output: Outputs,
+    session: Session,
+    csv_path: reactive.Value[str],
+    contributions: reactive.Value[int],
+    is_demo: bool,
+    lower_bounds: reactive.Value[dict[str, float]],
+    upper_bounds: reactive.Value[dict[str, float]],
+    bin_counts: reactive.Value[dict[str, int]],
+    weights: reactive.Value[dict[str, str]],
+    epsilon: reactive.Value[float],
 ):  # pragma: no cover
     @reactive.calc
     def button_enabled():
         column_ids_selected = input.columns_checkbox_group()
         return len(column_ids_selected) > 0
 
     @reactive.effect
-    def _update_checkbox_group():
+    def _update_checkbox_group():  # type: ignore unused function
         ui.update_checkbox_group(
             "columns_checkbox_group",
             label=None,
@@ -75,15 +78,15 @@ def _update_checkbox_group():
 
     @reactive.effect
     @reactive.event(input.columns_checkbox_group)
-    def _on_column_set_change():
+    def _on_column_set_change():  # type: ignore unused function
         column_ids_selected = input.columns_checkbox_group()
         # We only clean up the weights, and everything else is left in place,
         # so if you restore a column, you see the original values.
         # (Except for weight, which goes back to the default.)
         _cleanup_reactive_dict(weights, column_ids_selected)
 
     @render.ui
-    def columns_checkbox_group_tooltip_ui():
+    def columns_checkbox_group_tooltip_ui():  # type: ignore unused function
         return demo_tooltip(
             is_demo,
             """
@@ -94,7 +97,7 @@ def columns_checkbox_group_tooltip_ui():
         )
 
     @render.ui
-    def columns_ui():
+    def columns_ui():  # type: ignore unused function
         column_ids = input.columns_checkbox_group()
         column_ids_to_names = csv_ids_names_calc()
         column_ids_to_labels = csv_ids_labels_calc()
@@ -133,7 +136,7 @@ def columns_ui():
                             """
                             )
                         ],
-                        col_widths=col_widths,
+                        col_widths=col_widths,  # type: ignore
                     )
                     if column_ids
                     else []
@@ -150,7 +153,7 @@ def csv_ids_labels_calc():
         return read_csv_ids_labels(req(csv_path()))
 
     @render.ui
-    def epsilon_tooltip_ui():
+    def epsilon_tooltip_ui():  # type: ignore unused function
         return demo_tooltip(
             is_demo,
             """
@@ -162,24 +165,24 @@ def epsilon_tooltip_ui():
 
     @reactive.effect
     @reactive.event(input.log_epsilon_slider)
-    def _set_epsilon():
+    def _set_epsilon():  # type: ignore unused function
         epsilon.set(pow(10, input.log_epsilon_slider()))
 
     @render.text
-    def epsilon_text():
+    def epsilon_text():  # type: ignore unused function
         return f"Epsilon: {epsilon():0.3}"
 
     @render.code
-    def privacy_loss_python():
+    def privacy_loss_python():  # type: ignore unused function
         return make_privacy_loss_block(epsilon())
 
     @reactive.effect
     @reactive.event(input.go_to_results)
-    def go_to_results():
+    def go_to_results():  # type: ignore unused function
         ui.update_navs("top_level_nav", selected="results_panel")
 
     @render.ui
-    def download_results_button_ui():
+    def download_results_button_ui():  # type: ignore unused function
         button = ui.input_action_button(
             "go_to_results", "Download results", disabled=not button_enabled()
         )

dp_wizard/app/components/column_module.py

@@ -1,21 +1,21 @@
 from logging import info
 
-from shiny import ui, render, module, reactive
+from shiny import ui, render, module, reactive, Inputs, Outputs, Session
 
 from dp_wizard.utils.dp_helper import make_confidence_accuracy_histogram
 from dp_wizard.utils.shared import plot_histogram
 from dp_wizard.utils.templates import make_column_config_block
 from dp_wizard.app.components.outputs import output_code_sample, demo_tooltip
 
 
-default_weight = 2
+default_weight = "2"
 
 col_widths = {
     # Controls stay roughly a constant width;
     # Graph expands to fill space.
-    "sm": (4, 8),
-    "md": (3, 9),
-    "lg": (2, 10),
+    "sm": [4, 8],
+    "md": [3, 9],
+    "lg": [2, 10],
 }
 
 
@@ -37,9 +37,9 @@ def column_ui():  # pragma: no cover
                 "weight",
                 ["Weight", ui.output_ui("weight_tooltip_ui")],
                 choices={
-                    1: "Less accurate",
+                    "1": "Less accurate",
                     default_weight: "Default",
-                    4: "More accurate",
+                    "4": "More accurate",
                 },
                 selected=default_weight,
                 width=width,
@@ -50,54 +50,54 @@ def column_ui():  # pragma: no cover
             # Make plot smaller than default: about the same size as the other column.
             output_code_sample("Column Definition", "column_code"),
         ],
-        col_widths=col_widths,
+        col_widths=col_widths,  # type: ignore
     )
 
 
 @module.server
 def column_server(
-    input,
-    output,
-    session,
-    name,
-    contributions,
-    epsilon,
-    lower_bounds,
-    upper_bounds,
-    bin_counts,
-    weights,
-    is_demo,
+    input: Inputs,
+    output: Outputs,
+    session: Session,
+    name: str,
+    contributions: int,
+    epsilon: float,
+    lower_bounds: reactive.Value[dict[str, float]],
+    upper_bounds: reactive.Value[dict[str, float]],
+    bin_counts: reactive.Value[dict[str, int]],
+    weights: reactive.Value[dict[str, str]],
+    is_demo: bool,
 ):  # pragma: no cover
     @reactive.effect
-    def _set_all_inputs():
+    def _set_all_inputs():  # type: ignore
         with reactive.isolate():  # Without isolate, there is an infinite loop.
             ui.update_numeric("lower", value=lower_bounds().get(name, 0))
             ui.update_numeric("upper", value=upper_bounds().get(name, 10))
             ui.update_numeric("bins", value=bin_counts().get(name, 10))
-            ui.update_numeric("weight", value=weights().get(name, default_weight))
+            ui.update_numeric("weight", value=int(weights().get(name, default_weight)))
 
     @reactive.effect
     @reactive.event(input.lower)
-    def _set_lower():
+    def _set_lower():  # type: ignore
         lower_bounds.set({**lower_bounds(), name: float(input.lower())})
 
     @reactive.effect
     @reactive.event(input.upper)
-    def _set_upper():
+    def _set_upper():  # type: ignore
         upper_bounds.set({**upper_bounds(), name: float(input.upper())})
 
     @reactive.effect
     @reactive.event(input.bins)
-    def _set_bins():
-        bin_counts.set({**bin_counts(), name: float(input.bins())})
+    def _set_bins():  # type: ignore
+        bin_counts.set({**bin_counts(), name: int(input.bins())})
 
     @reactive.effect
     @reactive.event(input.weight)
-    def _set_weight():
-        weights.set({**weights(), name: float(input.weight())})
+    def _set_weight():  # type: ignore
+        weights.set({**weights(), name: input.weight()})
 
     @render.ui
-    def bounds_tooltip_ui():
+    def bounds_tooltip_ui():  # type: ignore
         return demo_tooltip(
             is_demo,
             """
@@ -111,7 +111,7 @@ def bounds_tooltip_ui():
         )
 
     @render.ui
-    def bins_tooltip_ui():
+    def bins_tooltip_ui():  # type: ignore
         return demo_tooltip(
             is_demo,
             """
@@ -124,7 +124,7 @@ def bins_tooltip_ui():
         )
 
     @render.ui
-    def weight_tooltip_ui():
+    def weight_tooltip_ui():  # type: ignore
         return demo_tooltip(
             is_demo,
             """
@@ -135,7 +135,7 @@ def weight_tooltip_ui():
         )
 
     @render.code
-    def column_code():
+    def column_code():  # type: ignore
         return make_column_config_block(
             name=name,
             lower_bound=float(input.lower()),
@@ -144,12 +144,12 @@ def column_code():
         )
 
     @render.plot()
-    def column_plot():
+    def column_plot():  # type: ignore
         lower_x = float(input.lower())
         upper_x = float(input.upper())
         bin_count = int(input.bins())
         weight = float(input.weight())
-        weights_sum = sum(weights().values())
+        weights_sum = sum(float(weight) for weight in weights().values())
         info(f"Weight ratio for {name}: {weight}/{weights_sum}")
         if weights_sum == 0:
             # This function is triggered when column is removed;

dp_wizard/app/components/inputs.py

@@ -2,7 +2,7 @@
 from shiny import ui
 
 
-def log_slider(id, lower, upper):
+def log_slider(id: str, lower: float, upper: float):
     # Rather than engineer a new widget, hide the numbers we don't want.
     # The rendered widget doesn't have a unique ID, but the following
     # element does, so we can use some fancy CSS to get the preceding element.

dp_wizard/app/components/outputs.py

@@ -3,14 +3,14 @@
 from faicons import icon_svg
 
 
-def output_code_sample(title, name_of_render_function):
+def output_code_sample(title: str, name_of_render_function: str):
     return details(
         summary(f"Code sample: {title}"),
         ui.output_code(name_of_render_function),
     )
 
 
-def demo_tooltip(is_demo, text):  # pragma: no cover
+def demo_tooltip(is_demo: bool, text: str):  # pragma: no cover
     if is_demo:
         return ui.tooltip(
             icon_svg("circle-question"),