├── .gitattributes
├── .github
├── ISSUE_TEMPLATE
│ ├── bug-report.yml
│ ├── config.yml
│ └── feature-request.yml
├── dependabot.yaml
├── pull_request_template.md
├── release.yml
└── workflows
│ ├── build.yml
│ ├── check-pr.yml
│ ├── docbuild.yml
│ └── lint.yml
├── .gitignore
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── NOTES_FOR_MAINTAINERS.md
├── README.md
├── RELEASING.md
├── altair
├── __init__.py
├── _magics.py
├── datasets
│ ├── __init__.py
│ ├── _cache.py
│ ├── _constraints.py
│ ├── _data.py
│ ├── _exceptions.py
│ ├── _loader.py
│ ├── _metadata
│ │ ├── metadata.csv.gz
│ │ ├── metadata.parquet
│ │ └── schemas.json.gz
│ ├── _reader.py
│ ├── _readimpl.py
│ └── _typing.py
├── expr
│ ├── __init__.py
│ ├── consts.py
│ ├── core.py
│ └── funcs.py
├── jupyter
│ ├── __init__.py
│ ├── js
│ │ ├── README.md
│ │ └── index.js
│ └── jupyter_chart.py
├── py.typed
├── theme.py
├── typing
│ └── __init__.py
├── utils
│ ├── __init__.py
│ ├── _dfi_types.py
│ ├── _importers.py
│ ├── _show.py
│ ├── _transformed_data.py
│ ├── _vegafusion_data.py
│ ├── compiler.py
│ ├── core.py
│ ├── data.py
│ ├── deprecation.py
│ ├── display.py
│ ├── execeval.py
│ ├── html.py
│ ├── mimebundle.py
│ ├── plugin_registry.py
│ ├── save.py
│ ├── schemapi.py
│ ├── selection.py
│ └── server.py
└── vegalite
│ ├── __init__.py
│ ├── api.py
│ ├── data.py
│ ├── display.py
│ ├── schema.py
│ └── v6
│ ├── __init__.py
│ ├── api.py
│ ├── compiler.py
│ ├── data.py
│ ├── display.py
│ ├── schema
│ ├── __init__.py
│ ├── _config.py
│ ├── _typing.py
│ ├── channels.py
│ ├── core.py
│ ├── mixins.py
│ ├── vega-lite-schema.json
│ └── vega-themes.json
│ └── theme.py
├── design
├── altair-logo-light.png
├── altair-logo-light.svg
├── altair-logo.png
└── altair-logo.svg
├── doc
├── .gitignore
├── _static
│ ├── altair-gallery.css
│ ├── altair-logo-light.png
│ ├── altair-plot.css
│ ├── chart.html
│ ├── custom.css
│ ├── favicon.ico
│ ├── gray-square.png
│ ├── jupyter_chart
│ │ ├── accessing_variable_params.mov
│ │ ├── index_selection_param.mov
│ │ ├── interval_selection_param.mov
│ │ ├── linking_interval_selection.mov
│ │ ├── linking_variable_params.mov
│ │ ├── linking_variable_params2.mov
│ │ ├── observing_variable_params.mov
│ │ ├── point_selection_param.mov
│ │ ├── setting_variable_params.mov
│ │ ├── simple_bar.svg
│ │ └── updating_charts.mov
│ ├── stocks_it-IT.svg
│ └── theme_overrides.css
├── _templates
│ ├── class.rst
│ ├── navbar-project.html
│ └── sidebar-logo.html
├── about
│ ├── citing.rst
│ ├── code_of_conduct.rst
│ ├── governance.rst
│ ├── roadmap.rst
│ └── versioning.rst
├── case_studies
│ ├── exploring-weather.rst
│ ├── index.rst
│ └── numpy-tooltip-images.rst
├── conf.py
├── getting_started
│ ├── getting_help.rst
│ ├── installation.rst
│ ├── overview.rst
│ ├── project_philosophy.rst
│ ├── resources.rst
│ └── starting.rst
├── index.rst
├── releases
│ └── changes.rst
└── user_guide
│ ├── api.rst
│ ├── compound_charts.rst
│ ├── configuration.rst
│ ├── custom_renderers.rst
│ ├── customization.rst
│ ├── data.rst
│ ├── data_transformers.rst
│ ├── display_frontends.rst
│ ├── encodings
│ ├── channel_options.rst
│ ├── channels.rst
│ └── index.rst
│ ├── interactions
│ ├── bindings_widgets.rst
│ ├── expressions.rst
│ ├── index.rst
│ ├── jupyter_chart.rst
│ └── parameters.rst
│ ├── internals.rst
│ ├── large_datasets.rst
│ ├── marks
│ ├── arc.rst
│ ├── area.rst
│ ├── bar.rst
│ ├── boxplot.rst
│ ├── circle.rst
│ ├── errorband.rst
│ ├── errorbar.rst
│ ├── geoshape.rst
│ ├── image.rst
│ ├── index.rst
│ ├── line.rst
│ ├── point.rst
│ ├── rect.rst
│ ├── rule.rst
│ ├── square.rst
│ ├── text.rst
│ ├── tick.rst
│ └── trail.rst
│ ├── saving_charts.rst
│ ├── scale_resolve.rst
│ ├── times_and_dates.rst
│ └── transform
│ ├── aggregate.rst
│ ├── bin.rst
│ ├── calculate.rst
│ ├── density.rst
│ ├── extent.rst
│ ├── filter.rst
│ ├── flatten.rst
│ ├── fold.rst
│ ├── impute.rst
│ ├── index.rst
│ ├── joinaggregate.rst
│ ├── loess.rst
│ ├── lookup.rst
│ ├── pivot.rst
│ ├── quantile.rst
│ ├── regression.rst
│ ├── sample.rst
│ ├── stack.rst
│ ├── timeunit.rst
│ └── window.rst
├── images
├── cars.png
└── cars_scatter_bar.gif
├── paper
├── paper.bib
├── paper.md
└── seattle_weather_interactive.png
├── pyproject.toml
├── sphinxext
├── __init__.py
├── altairgallery.py
├── code_ref.py
├── schematable.py
└── utils.py
├── tests
├── __init__.py
├── altair_theme_test.py
├── examples_arguments_syntax
│ ├── __init__.py
│ ├── airport_connections.py
│ ├── annual_weather_heatmap.py
│ ├── anscombe_plot.py
│ ├── area_chart_gradient.py
│ ├── area_faceted.py
│ ├── bar_and_line_with_dual_axis.py
│ ├── bar_chart_faceted_compact.py
│ ├── bar_chart_horizontal.py
│ ├── bar_chart_sorted.py
│ ├── bar_chart_with_highlighted_bar.py
│ ├── bar_chart_with_highlighted_segment.py
│ ├── bar_chart_with_labels.py
│ ├── bar_chart_with_labels_measured_luminance.py
│ ├── bar_chart_with_mean_line.py
│ ├── bar_chart_with_negatives.py
│ ├── bar_chart_with_range.py
│ ├── bar_chart_with_single_threshold.py
│ ├── bar_faceted_stacked.py
│ ├── bar_rounded.py
│ ├── bar_with_rolling_mean.py
│ ├── beckers_barley_facet.py
│ ├── beckers_barley_wrapped_facet.py
│ ├── boxplot.py
│ ├── bubble_plot.py
│ ├── bump_chart.py
│ ├── calculate_residuals.py
│ ├── candlestick_chart.py
│ ├── choropleth.py
│ ├── choropleth_repeat.py
│ ├── co2_concentration.py
│ ├── comet_chart.py
│ ├── cumulative_count_chart.py
│ ├── dendrogram.py
│ ├── density_repeat.py
│ ├── density_stack.py
│ ├── deviation_ellipses.py
│ ├── distributions_and_medians_of_likert_scale_ratings.py
│ ├── distributions_faceted_histogram.py
│ ├── diverging_stacked_bar_chart.py
│ ├── donut_chart.py
│ ├── dot_dash_plot.py
│ ├── empirical_cumulative_distribution_function.py
│ ├── errorbars_with_ci.py
│ ├── errorbars_with_std.py
│ ├── falkensee.py
│ ├── filled_step_chart.py
│ ├── gantt_chart.py
│ ├── gapminder_bubble_plot.py
│ ├── groupby-map.py
│ ├── grouped_bar_chart.py
│ ├── grouped_bar_chart2.py
│ ├── grouped_bar_chart_horizontal.py
│ ├── grouped_bar_chart_overlapping_bars.py
│ ├── grouped_bar_chart_with_error_bars.py
│ ├── heat_lane.py
│ ├── hexbins.py
│ ├── histogram_gradient_color.py
│ ├── histogram_heatmap.py
│ ├── histogram_responsive.py
│ ├── histogram_scatterplot.py
│ ├── histogram_with_a_global_mean_overlay.py
│ ├── horizon_graph.py
│ ├── horizontal_stacked_bar_chart.py
│ ├── interactive_aggregation.py
│ ├── interactive_bar_select_highlight.py
│ ├── interactive_brush.py
│ ├── interactive_column_selection.py
│ ├── interactive_cross_highlight.py
│ ├── interactive_layered_crossfilter.py
│ ├── interactive_legend.py
│ ├── interactive_reorder_stacked_bars.py
│ ├── interactive_scatter_plot.py
│ ├── interval_selection.py
│ ├── interval_selection_map_quakes.py
│ ├── iowa_electricity.py
│ ├── isotype.py
│ ├── isotype_emoji.py
│ ├── isotype_grid.py
│ ├── lasagna_plot.py
│ ├── layer_line_color_rule.py
│ ├── layered_area_chart.py
│ ├── layered_bar_chart.py
│ ├── layered_chart_bar_mark.py
│ ├── layered_chart_with_dual_axis.py
│ ├── layered_heatmap_text.py
│ ├── layered_histogram.py
│ ├── line_chart_with_arrows.py
│ ├── line_chart_with_color_datum.py
│ ├── line_chart_with_cumsum.py
│ ├── line_chart_with_cumsum_faceted.py
│ ├── line_chart_with_custom_legend.py
│ ├── line_chart_with_datum.py
│ ├── line_chart_with_generator.py
│ ├── line_chart_with_interpolation.py
│ ├── line_chart_with_points.py
│ ├── line_chart_with_points_stroked.py
│ ├── line_custom_order.py
│ ├── line_percent.py
│ ├── line_with_ci.py
│ ├── line_with_last_value_labeled.py
│ ├── line_with_log_scale.py
│ ├── london_tube.py
│ ├── maps_faceted_species.py
│ ├── mosaic_with_labels.py
│ ├── multi_series_line.py
│ ├── multifeature_scatter_plot.py
│ ├── multiline_highlight.py
│ ├── multiline_tooltip.py
│ ├── multiline_tooltip_standard.py
│ ├── multiple_interactions.py
│ ├── natural_disasters.py
│ ├── normalized_stacked_area_chart.py
│ ├── normalized_stacked_bar_chart.py
│ ├── normed_parallel_coordinates.py
│ ├── one_dot_per_zipcode.py
│ ├── pacman_chart.py
│ ├── parallel_coordinates.py
│ ├── percentage_of_total.py
│ ├── pie_chart.py
│ ├── pie_chart_with_labels.py
│ ├── point_map.py
│ ├── polar_bar_chart.py
│ ├── poly_fit_regression.py
│ ├── pyramid.py
│ ├── radial_chart.py
│ ├── ranged_dot_plot.py
│ ├── ridgeline_plot.py
│ ├── scatter_faceted.py
│ ├── scatter_href.py
│ ├── scatter_linked_brush.py
│ ├── scatter_linked_table.py
│ ├── scatter_marginal_hist.py
│ ├── scatter_matrix.py
│ ├── scatter_point_paths_hover.py
│ ├── scatter_qq.py
│ ├── scatter_tooltips.py
│ ├── scatter_with_histogram.py
│ ├── scatter_with_labels.py
│ ├── scatter_with_layered_histogram.py
│ ├── scatter_with_loess.py
│ ├── scatter_with_minimap.py
│ ├── scatter_with_rolling_mean.py
│ ├── scatter_with_shaded_area.py
│ ├── seattle_weather_interactive.py
│ ├── select_detail.py
│ ├── select_mark_area.py
│ ├── selection_histogram.py
│ ├── selection_layer_bar_month.py
│ ├── selection_zorder.py
│ ├── simple_bar_chart.py
│ ├── simple_heatmap.py
│ ├── simple_histogram.py
│ ├── simple_line_chart.py
│ ├── simple_scatter_with_errorbars.py
│ ├── simple_stacked_area_chart.py
│ ├── slider_cutoff.py
│ ├── slope_graph.py
│ ├── sorted_error_bars_with_ci.py
│ ├── stacked_bar_chart.py
│ ├── stacked_bar_chart_sorted_segments.py
│ ├── stacked_bar_chart_with_text.py
│ ├── stem_and_leaf.py
│ ├── step_chart.py
│ ├── streamgraph.py
│ ├── strip_plot.py
│ ├── strip_plot_jitter.py
│ ├── table_bubble_plot_github.py
│ ├── top_k_items.py
│ ├── top_k_letters.py
│ ├── top_k_with_others.py
│ ├── trail_marker.py
│ ├── us_employment.py
│ ├── us_incomebrackets_by_state_facet.py
│ ├── us_population_over_time.py
│ ├── us_population_over_time_facet.py
│ ├── us_population_pyramid_over_time.py
│ ├── us_state_capitals.py
│ ├── violin_plot.py
│ ├── waterfall_chart.py
│ ├── wheat_wages.py
│ ├── wilkinson-dot-plot.py
│ ├── wind_vector_map.py
│ ├── window_rank.py
│ ├── world_map.py
│ └── world_projections.py
├── examples_methods_syntax
│ ├── __init__.py
│ ├── airport_connections.py
│ ├── annual_weather_heatmap.py
│ ├── anscombe_plot.py
│ ├── area_faceted.py
│ ├── bar_chart_faceted_compact.py
│ ├── bar_chart_sorted.py
│ ├── bar_chart_with_labels_measured_luminance.py
│ ├── bar_chart_with_range.py
│ ├── bar_chart_with_single_threshold.py
│ ├── beckers_barley_facet.py
│ ├── beckers_barley_wrapped_facet.py
│ ├── bump_chart.py
│ ├── calculate_residuals.py
│ ├── candlestick_chart.py
│ ├── co2_concentration.py
│ ├── comet_chart.py
│ ├── cumulative_count_chart.py
│ ├── density_stack.py
│ ├── deviation_ellipses.py
│ ├── distributions_and_medians_of_likert_scale_ratings.py
│ ├── distributions_faceted_histogram.py
│ ├── diverging_stacked_bar_chart.py
│ ├── donut_chart.py
│ ├── errorbars_with_ci.py
│ ├── errorbars_with_std.py
│ ├── falkensee.py
│ ├── gapminder_bubble_plot.py
│ ├── groupby-map.py
│ ├── grouped_bar_chart2.py
│ ├── grouped_bar_chart_overlapping_bars.py
│ ├── grouped_bar_chart_with_error_bars.py
│ ├── heat_lane.py
│ ├── hexbins.py
│ ├── histogram_gradient_color.py
│ ├── histogram_heatmap.py
│ ├── histogram_responsive.py
│ ├── histogram_scatterplot.py
│ ├── histogram_with_a_global_mean_overlay.py
│ ├── horizon_graph.py
│ ├── interactive_aggregation.py
│ ├── interactive_bar_select_highlight.py
│ ├── interactive_column_selection.py
│ ├── interactive_cross_highlight.py
│ ├── interactive_layered_crossfilter.py
│ ├── interactive_legend.py
│ ├── interval_selection.py
│ ├── interval_selection_map_quakes.py
│ ├── iowa_electricity.py
│ ├── isotype.py
│ ├── isotype_emoji.py
│ ├── isotype_grid.py
│ ├── lasagna_plot.py
│ ├── layered_area_chart.py
│ ├── layered_bar_chart.py
│ ├── layered_chart_with_dual_axis.py
│ ├── layered_heatmap_text.py
│ ├── layered_histogram.py
│ ├── line_chart_with_color_datum.py
│ ├── line_chart_with_cumsum.py
│ ├── line_chart_with_cumsum_faceted.py
│ ├── line_chart_with_custom_legend.py
│ ├── line_custom_order.py
│ ├── line_percent.py
│ ├── line_with_ci.py
│ ├── line_with_last_value_labeled.py
│ ├── line_with_log_scale.py
│ ├── london_tube.py
│ ├── maps_faceted_species.py
│ ├── mosaic_with_labels.py
│ ├── multifeature_scatter_plot.py
│ ├── multiline_highlight.py
│ ├── multiline_tooltip.py
│ ├── multiline_tooltip_standard.py
│ ├── multiple_interactions.py
│ ├── natural_disasters.py
│ ├── normalized_stacked_area_chart.py
│ ├── normalized_stacked_bar_chart.py
│ ├── pacman_chart.py
│ ├── parallel_coordinates.py
│ ├── percentage_of_total.py
│ ├── pie_chart.py
│ ├── pie_chart_with_labels.py
│ ├── polar_bar_chart.py
│ ├── poly_fit_regression.py
│ ├── pyramid.py
│ ├── radial_chart.py
│ ├── ranged_dot_plot.py
│ ├── ridgeline_plot.py
│ ├── scatter_linked_table.py
│ ├── scatter_marginal_hist.py
│ ├── scatter_point_paths_hover.py
│ ├── scatter_with_layered_histogram.py
│ ├── scatter_with_minimap.py
│ ├── scatter_with_rolling_mean.py
│ ├── seattle_weather_interactive.py
│ ├── select_detail.py
│ ├── simple_scatter_with_errorbars.py
│ ├── sorted_error_bars_with_ci.py
│ ├── stacked_bar_chart_sorted_segments.py
│ ├── stacked_bar_chart_with_text.py
│ ├── stem_and_leaf.py
│ ├── streamgraph.py
│ ├── strip_plot_jitter.py
│ ├── top_k_items.py
│ ├── top_k_letters.py
│ ├── top_k_with_others.py
│ ├── us_employment.py
│ ├── us_population_over_time.py
│ ├── us_population_over_time_facet.py
│ ├── us_population_pyramid_over_time.py
│ ├── us_state_capitals.py
│ ├── violin_plot.py
│ ├── wheat_wages.py
│ ├── wilkinson-dot-plot.py
│ ├── wind_vector_map.py
│ └── window_rank.py
├── expr
│ ├── __init__.py
│ └── test_expr.py
├── test_datasets.py
├── test_examples.py
├── test_jupyter_chart.py
├── test_magics.py
├── test_toplevel.py
├── test_transformed_data.py
├── utils
│ ├── __init__.py
│ ├── test_compiler.py
│ ├── test_core.py
│ ├── test_data.py
│ ├── test_deprecation.py
│ ├── test_execeval.py
│ ├── test_html.py
│ ├── test_mimebundle.py
│ ├── test_plugin_registry.py
│ ├── test_schemapi.py
│ ├── test_server.py
│ ├── test_to_values_narwhals.py
│ └── test_utils.py
└── vegalite
│ ├── __init__.py
│ ├── test_common.py
│ └── v6
│ ├── __init__.py
│ ├── schema
│ ├── __init__.py
│ └── test_channels.py
│ ├── test_alias.py
│ ├── test_api.py
│ ├── test_data.py
│ ├── test_display.py
│ ├── test_geo_interface.py
│ ├── test_layer_props.py
│ ├── test_params.py
│ ├── test_renderers.py
│ └── test_theme.py
├── tools
├── __init__.py
├── codemod.py
├── datasets
│ ├── __init__.py
│ ├── datapackage.py
│ ├── models.py
│ └── npm.py
├── fs.py
├── generate_api_docs.py
├── generate_schema_wrapper.py
├── markup.py
├── schemapi
│ ├── __init__.py
│ ├── codegen.py
│ ├── schemapi.py
│ └── utils.py
├── sync_website.py
├── update_init_file.py
├── vega_expr.py
└── versioning.py
└── uv.lock
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto eol=lf
2 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/config.yml:
--------------------------------------------------------------------------------
1 | blank_issues_enabled: false
2 | contact_links:
3 | - name: Question
4 | url: https://stackoverflow.com/tags/altair
5 | about: Please ask questions such as "How do I do X?" or "Why does this not work?" on Stack Overflow using the `altair` tag.
6 | - name: Discussion
7 | url: https://github.com/vega/altair/discussions
8 | about: If you want to discuss a topic or ask a question that is not a good fit for Stack Overflow, please open a new disscussion here on GitHub.
9 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature-request.yml:
--------------------------------------------------------------------------------
1 | name: Feature request
2 | description: Suggest an improvement
3 | labels: ["enhancement"]
4 | body:
5 | - type: markdown
6 | attributes:
7 | value: |
8 | Thanks for taking the time to suggest a new feature!
9 |
10 | Note that since Altair is a Python wrapper around the Vega-Lite visualization grammar, [most feature requests should be reported directly to Vega-Lite](https://github.com/vega/vega-lite/issues). You can click the Action Button (`...`) of your Altair chart and "Open in Vega Editor" to see the Vega-Lite chart specification.
11 |
12 | If you believe this feature is more relevant for Altair than Vega-Lite, then make sure to search for duplicate issues before filling out the form below.
13 | - type: textarea
14 | id: what-happened
15 | attributes:
16 | label: What is your suggestion?
17 | description: Describe the feature's goal, motivating use cases, and its expected behavior.
18 | validations:
19 | required: true
20 | - type: textarea
21 | id: alternative-solutions
22 | attributes:
23 | label: Have you considered any alternative solutions?
24 |
--------------------------------------------------------------------------------
/.github/dependabot.yaml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 | - package-ecosystem: "github-actions"
4 | directory: "/"
5 | schedule:
6 | interval: "monthly"
7 | groups:
8 | github-actions:
9 | patterns:
10 | - "*"
11 | commit-message:
12 | prefix: "ci"
13 |
--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
1 | <!-- Click "Preview" to read this message; then delete it. -->
2 |
3 | ## Thanks for contributing to Altair! 🎉
4 |
5 | Please follow these guidelines:
6 |
7 | ### 1. **PR Description**
8 | - Briefly describe the changes and their purpose. For help, check this [guide](https://medium.com/@greenberg/writing-pull-requests-your-coworkers-might-enjoy-reading-9d0307e93da3).
9 |
10 | ### 2. **Tests & Docs**
11 | - Include unit tests and update documentation for new features.
12 |
13 | ### 3. **Commit Message**
14 | - Use [semantic commit messages](https://www.conventionalcommits.org/), e.g., `"feat: Add embed_options to charts"`.
15 | - Add `!` for breaking changes (e.g., `"fix!: Raise error when embed_options is None"`).
16 |
17 | ### 4. **PR Title Types**
18 | - **feat**: New feature
19 | - **fix**: Bug fix
20 | - **docs**: Documentation changes
21 | - **style**: Code style changes (no functionality change)
22 | - **refactor**: Code restructuring
23 | - **perf**: Performance improvements
24 | - **test**: Add or fix tests
25 | - **build**: Changes to build system or dependencies
26 | - **ci**: CI configuration changes
27 | - **chore**: Miscellaneous tasks
28 | - **revert**: Reverts a commit
29 |
--------------------------------------------------------------------------------
/.github/release.yml:
--------------------------------------------------------------------------------
1 | changelog:
2 | categories:
3 | - title: Breaking
4 | labels:
5 | - breaking
6 | - title: Deprecation
7 | labels:
8 | - deprecation
9 | - title: Enhancements
10 | labels:
11 | - enhancement
12 | - title: Bug Fixes
13 | labels:
14 | - bug
15 | - title: Maintainance
16 | labels:
17 | - maintainance
18 | - title: Documentation
19 | labels:
20 | - documentation
21 | - title: Other Changes
22 | labels:
23 | - "*"
24 |
--------------------------------------------------------------------------------
/.github/workflows/check-pr.yml:
--------------------------------------------------------------------------------
1 | name: "Lint PR"
2 |
3 | on:
4 | pull_request_target:
5 | types:
6 | - opened
7 | - edited
8 | - synchronize
9 |
10 | permissions:
11 | pull-requests: read
12 |
13 | jobs:
14 | main:
15 | name: Validate PR title
16 | runs-on: ubuntu-latest
17 | steps:
18 | - uses: amannn/action-semantic-pull-request@v5
19 | env:
20 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
21 |
--------------------------------------------------------------------------------
/.github/workflows/docbuild.yml:
--------------------------------------------------------------------------------
1 | name: docbuild
2 |
3 | on: [push, pull_request]
4 |
5 | jobs:
6 | build:
7 | runs-on: ubuntu-latest
8 | steps:
9 | - uses: actions/checkout@v4
10 | - name: Set up Python 3.12
11 | uses: actions/setup-python@v5
12 | with:
13 | python-version: "3.12"
14 | - name: Install uv
15 | uses: astral-sh/setup-uv@v6
16 | with:
17 | enable-cache: true
18 | cache-dependency-glob: |
19 | **/uv.lock
20 | **/pyproject.toml
21 | - name: Install dependencies
22 | run: uv sync --all-extras
23 | - name: Build docs
24 | run: |
25 | mkdir -p doc/_images
26 | uv run sphinx-build -b html -d doc/_build/doctrees doc doc/_build/html
27 | - name: Run doctests
28 | run: |
29 | uv run sphinx-build -b doctest -d doc/_build/doctrees doc doc/_build/doctest
30 |
31 |
32 |
--------------------------------------------------------------------------------
/.github/workflows/lint.yml:
--------------------------------------------------------------------------------
1 | name: lint
2 |
3 | on: [push, pull_request]
4 |
5 | jobs:
6 | build:
7 | runs-on: ubuntu-latest
8 | name: ruff-mypy
9 | steps:
10 | - name: "Set up Python"
11 | uses: actions/setup-python@v5
12 | with:
13 | python-version: "3.12"
14 | - uses: actions/checkout@v4
15 | - name: Install uv
16 | uses: astral-sh/setup-uv@v6
17 | with:
18 | enable-cache: true
19 | cache-dependency-glob: |
20 | **/uv.lock
21 | **/pyproject.toml
22 | # Installing all dependencies and not just the linters as mypy needs them for type checking
23 | - name: Install dependencies
24 | run: uv sync --all-extras
25 | - name: ruff check (lint)
26 | run: |
27 | uv run ruff check
28 | - name: ruff format
29 | run: |
30 | uv run ruff format --check --diff
31 | - name: mypy (type check)
32 | run: |
33 | uv run mypy altair tests
34 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 |
5 | # C extensions
6 | *.so
7 |
8 | # Distribution / packaging
9 | .Python
10 | env/
11 | venv
12 | .venv
13 | build/
14 | develop-eggs/
15 | dist/
16 | downloads/
17 | eggs/
18 | .eggs/
19 | lib/
20 | lib64/
21 | parts/
22 | sdist/
23 | var/
24 | *.egg-info/
25 | .installed.cfg
26 | *.egg
27 |
28 | # PyInstaller
29 | # Usually these files are written by a python script from a template
30 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
31 | *.manifest
32 | *.spec
33 |
34 | # Installer logs
35 | pip-log.txt
36 | pip-delete-this-directory.txt
37 |
38 | # Unit test / coverage reports
39 | htmlcov/
40 | .tox/
41 | .coverage
42 | .coverage.*
43 | .cache
44 | nosetests.xml
45 | coverage.xml
46 | *,cover
47 |
48 | # Translations
49 | *.mo
50 | *.pot
51 |
52 | # Django stuff:
53 | *.log
54 |
55 | # Sphinx documentation
56 | docs/_build/
57 |
58 | # PyBuilder
59 | target/
60 |
61 | # emacs backups
62 | *~
63 | \#*\#
64 |
65 | .ipynb_checkpoints
66 | .idea/*
67 | tools/_build
68 | Untitled*.ipynb
69 | .mypy*
70 | .pytest_cache
71 | *.DS_Store
72 |
73 | # VSCode
74 | .vscode
75 |
76 | # hatch, doc generation
77 | data.json
78 |
79 | # type stubs
80 | typings/
--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Contributor Covenant Code of Conduct
2 |
3 | As a project of the Vega Organization, we use the [Vega Code of Conduct](https://github.com/vega/.github/blob/main/CODE_OF_CONDUCT.md).
4 |
--------------------------------------------------------------------------------
/altair/datasets/_metadata/metadata.csv.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/altair/datasets/_metadata/metadata.csv.gz
--------------------------------------------------------------------------------
/altair/datasets/_metadata/metadata.parquet:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/altair/datasets/_metadata/metadata.parquet
--------------------------------------------------------------------------------
/altair/datasets/_metadata/schemas.json.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/altair/datasets/_metadata/schemas.json.gz
--------------------------------------------------------------------------------
/altair/expr/consts.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | CONST_LISTING = {
4 | "NaN": "not a number (same as JavaScript literal NaN)",
5 | "LN10": "the natural log of 10 (alias to Math.LN10)",
6 | "E": "the transcendental number e (alias to Math.E)",
7 | "LOG10E": "the base 10 logarithm e (alias to Math.LOG10E)",
8 | "LOG2E": "the base 2 logarithm of e (alias to Math.LOG2E)",
9 | "SQRT1_2": "the square root of 0.5 (alias to Math.SQRT1_2)",
10 | "LN2": "the natural log of 2 (alias to Math.LN2)",
11 | "SQRT2": "the square root of 2 (alias to Math.SQRT1_2)",
12 | "PI": "the transcendental number pi (alias to Math.PI)",
13 | }
14 |
--------------------------------------------------------------------------------
/altair/jupyter/__init__.py:
--------------------------------------------------------------------------------
1 | try:
2 | import anywidget # noqa: F401
3 | except ImportError:
4 | # When anywidget isn't available, create stand-in JupyterChart class
5 | # that raises an informative import error on construction. This
6 | # way we can make JupyterChart available in the altair namespace
7 | # when anywidget is not installed
8 | class JupyterChart:
9 | def __init__(self, *args, **kwargs):
10 | msg = (
11 | "The Altair JupyterChart requires the anywidget \n"
12 | "Python package which may be installed using pip with\n"
13 | " pip install anywidget\n"
14 | "or using conda with\n"
15 | " conda install -c conda-forge anywidget\n"
16 | "Afterwards, you will need to restart your Python kernel."
17 | )
18 | raise ImportError(msg)
19 |
20 | else:
21 | from .jupyter_chart import JupyterChart # noqa: F401
22 |
--------------------------------------------------------------------------------
/altair/jupyter/js/README.md:
--------------------------------------------------------------------------------
1 | # JupyterChart
2 | This directory contains the JavaScript portion of the Altair `JupyterChart`. The `JupyterChart` is based on the [AnyWidget](https://anywidget.dev/) project.
3 |
--------------------------------------------------------------------------------
/altair/py.typed:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/altair/py.typed
--------------------------------------------------------------------------------
/altair/utils/__init__.py:
--------------------------------------------------------------------------------
1 | from .core import (
2 | SHORTHAND_KEYS,
3 | display_traceback,
4 | infer_encoding_types,
5 | infer_vegalite_type_for_pandas,
6 | parse_shorthand,
7 | sanitize_narwhals_dataframe,
8 | sanitize_pandas_dataframe,
9 | update_nested,
10 | use_signature,
11 | )
12 | from .deprecation import AltairDeprecationWarning, deprecated, deprecated_warn
13 | from .html import spec_to_html
14 | from .plugin_registry import PluginRegistry
15 | from .schemapi import (
16 | VERSIONS,
17 | Optional,
18 | SchemaBase,
19 | SchemaLike,
20 | Undefined,
21 | is_undefined,
22 | )
23 |
24 | __all__ = (
25 | "SHORTHAND_KEYS",
26 | "VERSIONS",
27 | "AltairDeprecationWarning",
28 | "Optional",
29 | "PluginRegistry",
30 | "SchemaBase",
31 | "SchemaLike",
32 | "Undefined",
33 | "deprecated",
34 | "deprecated_warn",
35 | "display_traceback",
36 | "infer_encoding_types",
37 | "infer_vegalite_type_for_pandas",
38 | "is_undefined",
39 | "parse_shorthand",
40 | "sanitize_narwhals_dataframe",
41 | "sanitize_pandas_dataframe",
42 | "spec_to_html",
43 | "update_nested",
44 | "use_signature",
45 | )
46 |
--------------------------------------------------------------------------------
/altair/utils/compiler.py:
--------------------------------------------------------------------------------
1 | from collections.abc import Callable
2 | from typing import Any
3 |
4 | from altair.utils import PluginRegistry
5 |
6 | # ==============================================================================
7 | # Vega-Lite to Vega compiler registry
8 | # ==============================================================================
9 | VegaLiteCompilerType = Callable[[dict[str, Any]], dict[str, Any]]
10 |
11 |
12 | class VegaLiteCompilerRegistry(PluginRegistry[VegaLiteCompilerType, dict[str, Any]]):
13 | pass
14 |
--------------------------------------------------------------------------------
/altair/vegalite/__init__.py:
--------------------------------------------------------------------------------
1 | # ruff: noqa: F403
2 | from .v6 import *
3 |
--------------------------------------------------------------------------------
/altair/vegalite/api.py:
--------------------------------------------------------------------------------
1 | # ruff: noqa
2 | from .v6.api import *
3 |
--------------------------------------------------------------------------------
/altair/vegalite/display.py:
--------------------------------------------------------------------------------
1 | from altair.utils.display import (
2 | DefaultRendererReturnType,
3 | Displayable,
4 | HTMLRenderer,
5 | RendererRegistry,
6 | default_renderer_base,
7 | json_renderer_base,
8 | )
9 |
10 | __all__ = (
11 | "DefaultRendererReturnType",
12 | "Displayable",
13 | "HTMLRenderer",
14 | "RendererRegistry",
15 | "default_renderer_base",
16 | "json_renderer_base",
17 | )
18 |
--------------------------------------------------------------------------------
/altair/vegalite/schema.py:
--------------------------------------------------------------------------------
1 | """Altair schema wrappers."""
2 |
3 | # ruff: noqa: F403
4 | from .v6.schema import *
5 |
--------------------------------------------------------------------------------
/altair/vegalite/v6/compiler.py:
--------------------------------------------------------------------------------
1 | from typing import Final
2 |
3 | from altair.utils._importers import import_vl_convert
4 | from altair.utils.compiler import VegaLiteCompilerRegistry
5 |
6 | ENTRY_POINT_GROUP: Final = "altair.vegalite.v6.vegalite_compiler"
7 | vegalite_compilers = VegaLiteCompilerRegistry(entry_point_group=ENTRY_POINT_GROUP)
8 |
9 |
10 | def vl_convert_compiler(vegalite_spec: dict) -> dict:
11 | """Vega-Lite to Vega compiler that uses vl-convert."""
12 | from . import SCHEMA_VERSION
13 |
14 | vlc = import_vl_convert()
15 |
16 | # Compute vl-convert's vl_version string (of the form 'v5_8')
17 | # from SCHEMA_VERSION (of the form 'v5.8.0')
18 | vl_version = "_".join(SCHEMA_VERSION.split(".")[:2])
19 | return vlc.vegalite_to_vega(vegalite_spec, vl_version=vl_version)
20 |
21 |
22 | vegalite_compilers.register("vl-convert", vl_convert_compiler)
23 | vegalite_compilers.enable("vl-convert")
24 |
--------------------------------------------------------------------------------
/design/altair-logo-light.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/design/altair-logo-light.png
--------------------------------------------------------------------------------
/design/altair-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/design/altair-logo.png
--------------------------------------------------------------------------------
/doc/.gitignore:
--------------------------------------------------------------------------------
1 | _build
2 |
3 | # gallery is auto-generated; don't version-control it
4 | gallery
5 | _images
6 |
7 | # generated class documentation
8 | user_guide/generated
9 |
--------------------------------------------------------------------------------
/doc/_static/altair-logo-light.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/altair-logo-light.png
--------------------------------------------------------------------------------
/doc/_static/altair-plot.css:
--------------------------------------------------------------------------------
1 | .vega-actions a {
2 | margin-right: 12px;
3 | color: #757575;
4 | font-weight: normal;
5 | font-size: 13px;
6 | }
7 |
8 | .vega-embed {
9 | margin-bottom: 20px;
10 | margin-top: 20px;
11 | }
12 |
13 |
--------------------------------------------------------------------------------
/doc/_static/chart.html:
--------------------------------------------------------------------------------
1 | <!DOCTYPE html>
2 | <html>
3 | <head>
4 | <script src="https://cdn.jsdelivr.net/npm/vega@6"></script>
5 | <script src="https://cdn.jsdelivr.net/npm/vega-lite@6"></script>
6 | <script src="https://cdn.jsdelivr.net/npm/vega-embed@7"></script>
7 | </head>
8 | <body>
9 | <div id="vis"></div>
10 | <script type="text/javascript">
11 | var spec = {
12 | "$schema": "https://vega.github.io/schema/vega-lite/v6.json",
13 | "config": {
14 | "view": {
15 | "continuousHeight": 300,
16 | "continuousWidth": 300
17 | }
18 | },
19 | "data": {
20 | "url": "https://vega.github.io/vega-datasets/data/cars.json"
21 | },
22 | "encoding": {
23 | "color": {
24 | "field": "Origin",
25 | "type": "nominal"
26 | },
27 | "x": {
28 | "field": "Horsepower",
29 | "type": "quantitative"
30 | },
31 | "y": {
32 | "field": "Miles_per_Gallon",
33 | "type": "quantitative"
34 | }
35 | },
36 | "mark": "point"
37 | };
38 | var opt = {"renderer": "canvas", "actions": false};
39 | vegaEmbed("#vis", spec, opt);
40 | </script>
41 | </body>
42 | </html>
43 |
--------------------------------------------------------------------------------
/doc/_static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/favicon.ico
--------------------------------------------------------------------------------
/doc/_static/gray-square.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/gray-square.png
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/accessing_variable_params.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/accessing_variable_params.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/index_selection_param.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/index_selection_param.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/interval_selection_param.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/interval_selection_param.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/linking_interval_selection.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/linking_interval_selection.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/linking_variable_params.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/linking_variable_params.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/linking_variable_params2.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/linking_variable_params2.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/observing_variable_params.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/observing_variable_params.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/point_selection_param.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/point_selection_param.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/setting_variable_params.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/setting_variable_params.mov
--------------------------------------------------------------------------------
/doc/_static/jupyter_chart/updating_charts.mov:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/doc/_static/jupyter_chart/updating_charts.mov
--------------------------------------------------------------------------------
/doc/_static/theme_overrides.css:
--------------------------------------------------------------------------------
1 | /* override table width restrictions */
2 | @media screen and (min-width: 767px) {
3 |
4 | .wy-table-responsive table td {
5 | /* !important prevents the common CSS stylesheets from overriding
6 | this as on RTD they are loaded after this stylesheet */
7 | white-space: normal !important;
8 | }
9 | .wy-table-responsive {
10 | overflow: visible !important;
11 | }
12 | }
13 |
14 | .rst-content dl:not(.docutils) dt em {
15 | font-style: normal !important;
16 | line-height: 1.4em !important;
17 | }
18 |
19 | .rst-content div[class^='highlight'] {
20 | background: #fff !important;
21 | }
22 |
23 | img.logo {
24 | width: 120px !important;
25 | }
26 |
27 | /* Increase max-width of the content area slightly to accommodate larger screens */
28 | .bd-main .bd-content .bd-article-container {
29 | max-width: 1000px;
30 | }
31 |
--------------------------------------------------------------------------------
/doc/_templates/class.rst:
--------------------------------------------------------------------------------
1 | :mod:`{{module}}`.{{objname}}
2 | {{ underline }}==============
3 |
4 | .. currentmodule:: {{ module }}
5 |
6 | .. autoclass:: {{ objname }}
7 |
8 | {% block methods %}
9 | .. automethod:: __init__
10 | {% endblock %}
11 |
12 | .. raw:: html
13 |
14 | <div class="clearer"></div>
15 |
--------------------------------------------------------------------------------
/doc/_templates/navbar-project.html:
--------------------------------------------------------------------------------
1 | <a class="navbar-brand" href="{{ pathto(master_doc) }}">
2 | <p class="title">{{ project }}</p>
3 | </a>
4 |
5 |
--------------------------------------------------------------------------------
/doc/_templates/sidebar-logo.html:
--------------------------------------------------------------------------------
1 | <div class="navbar-brand-box">
2 | <a class="navbar-brand text-wrap" href="{{ pathto('index') }}">
3 | {% if logo %}
4 | <!-- `logo` is deprecated in Sphinx 4.0, so remove this when we stop supporting 3 -->
5 | {% set logo_url=logo %}
6 | {% endif %}
7 | {% if logo_url %}
8 | <img src="{{ pathto('_static/' + logo, 1) }}" class="logo" alt="logo">
9 | <br>
10 | <p class="site-version" id="site-version">{{ version }}</p>
11 | {% endif %}
12 | </a>
13 | </div>
14 |
--------------------------------------------------------------------------------
/doc/about/code_of_conduct.rst:
--------------------------------------------------------------------------------
1 | Code of Conduct
2 | ===============
3 |
4 | As a project of the Vega Organization, we use the `Vega Code of Conduct <https://github.com/vega/.github/blob/main/CODE_OF_CONDUCT.md>`_.
5 |
--------------------------------------------------------------------------------
/doc/about/governance.rst:
--------------------------------------------------------------------------------
1 | Governance
2 | ==========
3 | Vega-Altair's governance structure is based on GitHub's
4 | `Minimum Viable Governance <https://github.com/github/MVG>`_ (MVG) template.
5 |
6 | Organizational Governance
7 | -------------------------
8 | The Altair-Viz organization is governed by the documents that reside in the
9 | `Vega Organizational GitHub repository <https://github.com/vega/.github/>`_.
10 |
11 | Project Governance
12 | ------------------
13 | The Vega-Altair library is governed by the documents that reside in the
14 | `project-docs <https://github.com/vega/.github/blob/main/project-docs/>`_ directory of
15 | the Vega Organizational GitHub repository.
--------------------------------------------------------------------------------
/doc/about/roadmap.rst:
--------------------------------------------------------------------------------
1 | Roadmap
2 | =======
3 |
4 | The roadmap for Vega-Altair and related projects can be found in
5 | `this project board <https://github.com/orgs/vega/projects/9/views/3?pane=info>`_.
6 |
7 | .. toctree::
8 | :maxdepth: 1
9 | :caption: About
10 | :hidden:
11 |
12 | self
13 | code_of_conduct
14 | governance
15 | citing
16 | versioning
17 |
--------------------------------------------------------------------------------
/doc/case_studies/index.rst:
--------------------------------------------------------------------------------
1 | Tutorials
2 | ---------
3 |
4 | These tutorials explore more advanced use cases than the gallery.
5 |
6 | .. toctree::
7 | :hidden:
8 |
9 | exploring-weather
10 | numpy-tooltip-images
11 |
--------------------------------------------------------------------------------
/doc/getting_started/getting_help.rst:
--------------------------------------------------------------------------------
1 | Getting Help
2 | ============
3 |
4 | Altair is BSD-licensed and the source is available on `GitHub`_,
5 | where you can also report `bugs and feature requests`_.
6 | For general questions, please ask on `StackOverflow`_
7 | using the `altair` tag.
8 |
9 | You can browse this documentation
10 | via the links in the top navigation panel
11 | or by viewing the full site :ref:`genindex`.
12 | In addition to reading this documentation page,
13 | it can be helpful to also browse the `Vega-Lite documentation <https://vega.github.io/vega-lite/docs/>`_.
14 |
15 | .. _GitHub: http://github.com/vega/altair
16 | .. _Git Issues: http://github.com/vega/altair/issues
17 | .. _Vega: http://vega.github.io/vega
18 | .. _Vega-Lite: http://vega.github.io/vega-lite
19 | .. _bugs and feature requests: https://github.com/vega/altair/issues/new/choose
20 | .. _StackOverflow: https://stackoverflow.com/tags/altair
21 |
--------------------------------------------------------------------------------
/doc/releases/changes.rst:
--------------------------------------------------------------------------------
1 | :orphan:
2 |
3 | Release Notes
4 | =============
5 |
6 | We have moved the release notes to GitHub. You can now find them `here <https://github.com/vega/altair/releases>`_.
7 |
--------------------------------------------------------------------------------
/doc/user_guide/marks/circle.rst:
--------------------------------------------------------------------------------
1 | .. currentmodule:: altair
2 |
3 | .. _user-guide-circle-marks:
4 |
5 | Circle
6 | ~~~~~~
7 |
8 | ``circle`` mark is similar to ``point`` mark, except that (1) the ``shape`` value is always set to ``circle`` (2) they are filled by default.
9 |
10 | Circle Mark Properties
11 | ^^^^^^^^^^^^^^^^^^^^^^
12 | A ``circle`` mark definition can contain any :ref:`standard mark properties <mark-properties>`
13 | and the following special properties:
14 |
15 | .. altair-object-table:: altair.MarkDef
16 | :properties: size
17 |
18 | Scatter Plot with Circle
19 | ^^^^^^^^^^^^^^^^^^^^^^^^
20 |
21 | Here is an example scatter plot with ``circle`` marks:
22 |
23 | .. altair-plot::
24 | import altair as alt
25 | from vega_datasets import data
26 |
27 | source = data.cars.url
28 |
29 | alt.Chart(source).mark_circle().encode(
30 | x=("Horsepower:Q"),
31 | y=("Miles_per_Gallon:Q"),
32 | )
33 |
34 |
35 |
--------------------------------------------------------------------------------
/doc/user_guide/marks/square.rst:
--------------------------------------------------------------------------------
1 | .. currentmodule:: altair
2 |
3 | .. _user-guide-square-marks:
4 |
5 | Square
6 | ~~~~~~
7 | ``square`` mark is similar to ``point`` mark, except that (1) the ``shape`` value is always set to ``square`` (2) they are filled by default.
8 |
9 | Square Mark Properties
10 | ----------------------
11 | A ``square`` mark definition can contain any :ref:`standard mark properties <mark-properties>`
12 | and the following special properties:
13 |
14 | .. altair-object-table:: altair.MarkDef
15 | :properties: size
16 |
17 | Scatter Plot with Square
18 | ------------------------
19 | .. altair-plot::
20 | import altair as alt
21 | from vega_datasets import data
22 |
23 | source = data.cars()
24 |
25 | alt.Chart(source).mark_square().encode(
26 | x="Horsepower:Q",
27 | y="Miles_per_Gallon:Q",
28 | )
29 |
--------------------------------------------------------------------------------
/doc/user_guide/transform/loess.rst:
--------------------------------------------------------------------------------
1 | .. currentmodule:: altair
2 |
3 | .. _user-guide-loess-transform:
4 |
5 | LOESS
6 | ~~~~~
7 | The LOESS transform (LOcally Estimated Scatterplot Smoothing) uses a
8 | locally-estimated regression to produce a trend line.
9 | LOESS performs a sequence of local weighted regressions over a sliding
10 | window of nearest-neighbor points. For standard parametric regression options,
11 | see the :ref:`user-guide-regression-transform`.
12 |
13 | Here is an example of using LOESS to smooth samples from a Gaussian random walk:
14 |
15 | .. altair-plot::
16 |
17 | import altair as alt
18 | import pandas as pd
19 | import numpy as np
20 |
21 | np.random.seed(42)
22 |
23 | df = pd.DataFrame({
24 | 'x': range(100),
25 | 'y': np.random.randn(100).cumsum()
26 | })
27 |
28 | chart = alt.Chart(df).mark_point().encode(
29 | x='x',
30 | y='y'
31 | )
32 |
33 | chart + chart.transform_loess('x', 'y').mark_line()
34 |
35 |
36 | Transform Options
37 | ^^^^^^^^^^^^^^^^^
38 | The :meth:`~Chart.transform_loess` method is built on the
39 | :class:`~LoessTransform` class, which has the following options:
40 |
41 | .. altair-object-table:: altair.LoessTransform
42 |
--------------------------------------------------------------------------------
/doc/user_guide/transform/quantile.rst:
--------------------------------------------------------------------------------
1 | .. currentmodule:: altair
2 |
3 | .. _user-guide-quantile-transform:
4 |
5 | Quantile
6 | ~~~~~~~~
7 | The quantile transform calculates empirical `quantile <https://en.wikipedia.org/wiki/Quantile>`_
8 | values for input data. If a groupby parameter is provided, quantiles are estimated
9 | separately per group. Among other uses, the quantile transform is useful for creating
10 | `quantile-quantile (Q-Q) plots <https://en.wikipedia.org/wiki/Q%E2%80%93Q_plot>`_.
11 |
12 | Here is an example of a quantile plot of normally-distributed data:
13 |
14 | .. altair-plot::
15 |
16 | import altair as alt
17 | import pandas as pd
18 | import numpy as np
19 |
20 | np.random.seed(42)
21 | df = pd.DataFrame({'x': np.random.randn(200)})
22 |
23 | alt.Chart(df).transform_quantile(
24 | 'x', step=0.01
25 | ).mark_point().encode(
26 | x='prob:Q',
27 | y='value:Q'
28 | )
29 |
30 | Transform Options
31 | ^^^^^^^^^^^^^^^^^
32 | The :meth:`~Chart.transform_quantile` method is built on the :class:`~QuantileTransform`
33 | class, which has the following options:
34 |
35 | .. altair-object-table:: altair.QuantileTransform
36 |
--------------------------------------------------------------------------------
/doc/user_guide/transform/sample.rst:
--------------------------------------------------------------------------------
1 | .. currentmodule:: altair
2 |
3 | .. _user-guide-sample-transform:
4 |
5 | Sample
6 | ~~~~~~
7 | The sample transform is one of the simpler of all Altair's data transforms;
8 | it takes a single parameter ``sample`` which specified a number of rows to
9 | randomly choose from the dataset. The resulting chart will be created using
10 | only this random subset of the data.
11 |
12 | For example, here we chart the full cars dataset alongside a sample of 100
13 | rows:
14 |
15 | .. altair-plot::
16 |
17 | import altair as alt
18 | from vega_datasets import data
19 |
20 | source = data.cars.url
21 |
22 | chart = alt.Chart(source).mark_point().encode(
23 | x='Horsepower:Q',
24 | y='Miles_per_Gallon:Q',
25 | color='Origin:N'
26 | ).properties(
27 | width=200,
28 | height=200
29 | )
30 |
31 | chart | chart.transform_sample(100)
32 |
33 |
34 | Transform Options
35 | ^^^^^^^^^^^^^^^^^
36 | The :meth:`~Chart.transform_sample` method is built on the :class:`~SampleTransform`
37 | class, which has the following options:
38 |
39 | .. altair-object-table:: altair.SampleTransform
40 |
--------------------------------------------------------------------------------
/images/cars.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/images/cars.png
--------------------------------------------------------------------------------
/images/cars_scatter_bar.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/images/cars_scatter_bar.gif
--------------------------------------------------------------------------------
/paper/seattle_weather_interactive.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/paper/seattle_weather_interactive.png
--------------------------------------------------------------------------------
/sphinxext/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/sphinxext/__init__.py
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/__init__.py:
--------------------------------------------------------------------------------
1 | import os
2 | from typing import Set
3 |
4 | # Set of the names of examples that should have SVG static images.
5 | # This is for examples that VlConvert's PNG export does not support.
6 | SVG_EXAMPLES: Set[str] = {"isotype_emoji"}
7 |
8 |
9 | def iter_examples_arguments_syntax():
10 | """Iterate over the examples in this directory.
11 |
12 | Each item is a dict with the following keys:
13 | - "name" : the unique name of the example
14 | - "filename" : the full file path to the example
15 | - "use_svg": Flag indicating whether the static image for the
16 | example should be an SVG instead of a PNG
17 | """
18 | examples_arguments_syntax_dir = os.path.abspath(os.path.dirname(__file__))
19 | for filename in os.listdir(examples_arguments_syntax_dir):
20 | name, ext = os.path.splitext(filename)
21 | if name.startswith("_") or ext != ".py":
22 | continue
23 | yield {
24 | "name": name,
25 | "filename": os.path.join(examples_arguments_syntax_dir, filename),
26 | "use_svg": name in SVG_EXAMPLES,
27 | }
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/annual_weather_heatmap.py:
--------------------------------------------------------------------------------
1 | """
2 | Annual Weather Heatmap
3 | ----------------------
4 | """
5 | # category: tables
6 | import altair as alt
7 | from vega_datasets import data
8 |
9 | source = data.seattle_weather()
10 |
11 | alt.Chart(source, title="Daily Max Temperatures (C) in Seattle, WA").mark_rect().encode(
12 | x=alt.X("date(date):O", title="Day", axis=alt.Axis(format="%e", labelAngle=0)),
13 | y=alt.Y("month(date):O", title="Month"),
14 | color=alt.Color("max(temp_max)", legend=alt.Legend(title=None)),
15 | tooltip=[
16 | alt.Tooltip("monthdate(date)", title="Date"),
17 | alt.Tooltip("max(temp_max)", title="Max Temp"),
18 | ],
19 | ).configure_view(step=13, strokeWidth=0).configure_axis(domain=False)
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/anscombe_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Anscombe's Quartet
3 | ------------------
4 |
5 | `Anscombe's Quartet <https://en.wikipedia.org/wiki/Anscombe%27s_quartet>`_
6 | is a famous dataset constructed by Francis Anscombe.
7 | It is made of 4 different subsets of data.
8 | Each subset has very different characteristics, even though common summary
9 | statistics such as mean and variance are identical.
10 |
11 | This example shows how to make a faceted plot, with each facet
12 | showing a different subset of the data.
13 | """
14 | # category: case studies
15 | import altair as alt
16 | from vega_datasets import data
17 |
18 | source = data.anscombe()
19 |
20 | alt.Chart(source).mark_circle().encode(
21 | alt.X("X", scale=alt.Scale(zero=False)),
22 | alt.Y("Y", scale=alt.Scale(zero=False)),
23 | alt.Facet("Series", columns=2),
24 | ).properties(
25 | width=180,
26 | height=180,
27 | )
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/area_chart_gradient.py:
--------------------------------------------------------------------------------
1 | """
2 | Area Chart with Gradient
3 | ------------------------
4 | This example shows how to make an area chart with a gradient fill.
5 | For more information about gradient options see the Vega-Lite `Gradient documentation <https://vega.github.io/vega-lite/docs/types.html#gradient>`_.
6 | """
7 | # category: area charts
8 |
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.stocks()
13 |
14 | alt.Chart(source).transform_filter(
15 | 'datum.symbol==="GOOG"'
16 | ).mark_area(
17 | line={'color':'darkgreen'},
18 | color=alt.Gradient(
19 | gradient='linear',
20 | stops=[alt.GradientStop(color='white', offset=0),
21 | alt.GradientStop(color='darkgreen', offset=1)],
22 | x1=1,
23 | x2=1,
24 | y1=1,
25 | y2=0
26 | )
27 | ).encode(
28 | alt.X('date:T'),
29 | alt.Y('price:Q')
30 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/area_faceted.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Area Chart
3 | ------------------
4 | Multiple area subcharts, one for each company.
5 | We also show filtering out one of the companies,
6 | and sorting the companies in a custom order.
7 | """
8 | # category: area charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.stocks()
13 |
14 | alt.Chart(source).transform_filter(
15 | alt.datum.symbol != "GOOG",
16 | ).mark_area().encode(
17 | x="date:T",
18 | y="price:Q",
19 | color="symbol:N",
20 | row=alt.Row("symbol:N", sort=["MSFT", "AAPL", "IBM", "AMZN"]),
21 | ).properties(height=50, width=400)
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_and_line_with_dual_axis.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Line on Dual Axis
3 | --------------------------------
4 | This example shows how to combine two plots and keep their axes.
5 |
6 | For a more polished version of this chart, see :ref:`gallery_wheat_wages`.
7 | """
8 | # category: bar charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.wheat()
13 |
14 | base = alt.Chart(source).encode(x='year:O')
15 |
16 | bar = base.mark_bar().encode(y='wheat:Q')
17 |
18 | line = base.mark_line(color='red').encode(
19 | y='wages:Q'
20 | )
21 |
22 | (bar + line).properties(width=600)
23 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_horizontal.py:
--------------------------------------------------------------------------------
1 | """
2 | Horizontal Bar Chart
3 | --------------------
4 | This example is a bar chart drawn horizontally by putting the quantitative value on the x axis.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='wheat:Q',
14 | y="year:O"
15 | ).properties(height=700)
16 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_sorted.py:
--------------------------------------------------------------------------------
1 | """
2 | Sorted Bar Chart
3 | ================
4 | This example shows a bar chart sorted by a calculated value.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield):Q',
14 | y=alt.Y('site:N', sort='-x')
15 | )
16 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_highlighted_bar.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Highlighted Bar
3 | ------------------------------
4 | This example shows a basic bar chart with a single bar highlighted.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | # If the `year` column equals `1810`
13 | # then, set the bar color to `"orange"`
14 | # otherwise, use `"steelblue"`
15 | color = alt.when(year=1810).then(alt.value("orange")).otherwise(alt.value("steelblue"))
16 |
17 | alt.Chart(source).mark_bar().encode(
18 | x="year:O",
19 | y="wheat:Q",
20 | color=color
21 | ).properties(width=600)
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_highlighted_segment.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Highlighted Segment
3 | ----------------------------------
4 | This example shows a bar chart that highlights values beyond a threshold.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | import pandas as pd
9 | from vega_datasets import data
10 |
11 | source = data.wheat()
12 | threshold = pd.DataFrame([{"threshold": 90}])
13 |
14 | bars = alt.Chart(source).mark_bar().encode(
15 | x="year:O",
16 | y="wheat:Q",
17 | )
18 |
19 | highlight = alt.Chart(source).mark_bar(color="#e45755").encode(
20 | x='year:O',
21 | y='baseline:Q',
22 | y2='wheat:Q'
23 | ).transform_filter(
24 | alt.datum.wheat > 90
25 | ).transform_calculate("baseline", "90")
26 |
27 | rule = alt.Chart(threshold).mark_rule().encode(
28 | y='threshold:Q'
29 | )
30 |
31 | (bars + highlight + rule).properties(width=600)
32 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_labels.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Labels
3 | =====================
4 | This example shows a basic horizontal bar chart with labels created with Altair.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 |
11 | source = data.wheat()
12 |
13 | base = alt.Chart(source).encode(
14 | x='wheat',
15 | y="year:O",
16 | text='wheat'
17 | )
18 | base.mark_bar() + base.mark_text(align='left', dx=2)
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_labels_measured_luminance.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Labels based on Measured Luminance
3 | =================================================
4 | This example shows a basic horizontal bar chart with labels where the measured luminance to decides if the text overlay is be colored ``black`` or ``white``.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | base = alt.Chart(source).encode(
13 | x=alt.X('sum(yield):Q', stack='zero'),
14 | y=alt.Y('site:O', sort='-x'),
15 | text=alt.Text('sum(yield):Q', format='.0f')
16 | )
17 |
18 | bars = base.mark_bar(
19 | tooltip=alt.expr("luminance(scale('color', datum.sum_yield))")
20 | ).encode(
21 | color='sum(yield):Q'
22 | )
23 |
24 | text = base.mark_text(
25 | align='right',
26 | dx=-3,
27 | color=alt.expr("luminance(scale('color', datum.sum_yield)) > 0.5 ? 'black' : 'white'")
28 | )
29 |
30 | bars + text
31 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_mean_line.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Line at Mean
3 | ---------------------------
4 | This example shows the mean value overlaid on a bar chart.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | bar = alt.Chart(source).mark_bar().encode(
13 | x='year:O',
14 | y='wheat:Q'
15 | )
16 |
17 | rule = alt.Chart(source).mark_rule(color='red').encode(
18 | y='mean(wheat):Q'
19 | )
20 |
21 | (bar + rule).properties(width=600)
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_negatives.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Negative Values
3 | ==============================
4 | This example shows a bar chart with both positive and negative values.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.us_employment()
11 |
12 | predicate = alt.datum.nonfarm_change > 0
13 | color = alt.when(predicate).then(alt.value("steelblue")).otherwise(alt.value("orange"))
14 |
15 | alt.Chart(source).mark_bar().encode(
16 | x="month:T",
17 | y="nonfarm_change:Q",
18 | color=color
19 | ).properties(width=600)
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_range.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Range
3 | ====================
4 | This example shows a range bar chart where each bar displays information of a low and high value.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.seattle_weather()
11 |
12 | bar = alt.Chart(source).mark_bar(cornerRadius=10, height=10).encode(
13 | x=alt.X('min(temp_min):Q', scale=alt.Scale(domain=[-15, 45]), title='Temperature (°C)'),
14 | x2='max(temp_max):Q',
15 | y=alt.Y('month(date):O', title=None)
16 | )
17 |
18 | text_min = alt.Chart(source).mark_text(align='right', dx=-5).encode(
19 | x='min(temp_min):Q',
20 | y=alt.Y('month(date):O'),
21 | text='min(temp_min):Q'
22 | )
23 |
24 | text_max = alt.Chart(source).mark_text(align='left', dx=5).encode(
25 | x='max(temp_max):Q',
26 | y=alt.Y('month(date):O'),
27 | text='max(temp_max):Q'
28 | )
29 |
30 | (bar + text_min + text_max).properties(
31 | title=alt.Title(text='Temperature variation by month', subtitle='Seatle weather, 2012-2015')
32 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_chart_with_single_threshold.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart Highlighting Values beyond a Threshold
3 | ------------------------------------------------
4 | This example shows a bar chart highlighting values beyond a threshold.
5 | """
6 | # category: bar charts
7 | import pandas as pd
8 | import altair as alt
9 |
10 | source = pd.DataFrame({
11 | "Day": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
12 | "Value": [55, 112, 65, 38, 80, 138, 120, 103, 395, 200, 72, 51, 112, 175, 131]
13 | })
14 | threshold = 300
15 |
16 | bars = alt.Chart(source).mark_bar(color="steelblue").encode(
17 | x="Day:O",
18 | y="Value:Q",
19 | )
20 |
21 | highlight = bars.mark_bar(color="#e45755").encode(
22 | y2=alt.Y2(datum=threshold)
23 | ).transform_filter(
24 | alt.datum.Value > threshold
25 | )
26 |
27 | rule = alt.Chart().mark_rule().encode(
28 | y=alt.Y(datum=threshold)
29 | )
30 |
31 | label = rule.mark_text(
32 | x="width",
33 | dx=-2,
34 | align="right",
35 | baseline="bottom",
36 | text="hazardous"
37 | )
38 |
39 | (bars + highlight + rule + label)
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_faceted_stacked.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Stacked Bar Chart
3 | =========================
4 | A horizontal stacked bar chart using barley crop yield data.
5 | The chart is horizontally faceted based on the year,
6 | and vertically faceted based on variety.
7 | """
8 | # category: bar charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.barley()
13 |
14 | alt.Chart(source).mark_bar().encode(
15 | column="year:O",
16 | x="yield",
17 | y="variety",
18 | color="site",
19 | ).properties(width=220)
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_rounded.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Rounded Edges
3 | ----------------------------
4 | This example shows how to create a bar chart with rounded edges.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.seattle_weather()
11 |
12 | alt.Chart(source).mark_bar(
13 | cornerRadiusTopLeft=3,
14 | cornerRadiusTopRight=3
15 | ).encode(
16 | x='month(date):O',
17 | y='count():Q',
18 | color='weather:N'
19 | )
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bar_with_rolling_mean.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Rolling Mean
3 | ---------------------------
4 | A bar chart overlaid with a rolling mean. In this example the average of values over the previous decade is displayed as a line.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | bar = alt.Chart(source).mark_bar().encode(
13 | x='year:O',
14 | y='wheat:Q'
15 | )
16 |
17 | line = alt.Chart(source).mark_line(color='red').transform_window(
18 | # The field to average
19 | rolling_mean='mean(wheat)',
20 | # The number of values before and after the current value to include.
21 | frame=[-9, 0]
22 | ).encode(
23 | x='year:O',
24 | y='rolling_mean:Q'
25 | )
26 |
27 | (bar + line).properties(width=600)
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/beckers_barley_wrapped_facet.py:
--------------------------------------------------------------------------------
1 | """
2 | Becker's Barley Wrapped Facet Plot
3 | ----------------------------------
4 | The example demonstrates the faceted charts created by Richard Becker,
5 | William Cleveland and others in the 1990s. Using the visualization technique
6 | where each row is a different site (i.e. the chart is faceted by site),
7 | they identified an anomaly in a widely used agriculatural dataset,
8 | where the "Morris" site accidentally had the years 1931 and 1932 swapped.
9 | They named this
10 | `"The Morris Mistake." <http://ml.stat.purdue.edu/stat695t/writings/Trellis.User.pdf>`_.
11 | """
12 | # category: case studies
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.barley.url
17 |
18 | alt.Chart(source).mark_point().encode(
19 | alt.X("median(yield):Q", scale=alt.Scale(zero=False)),
20 | y="variety:O",
21 | color="year:N",
22 | facet=alt.Facet("site:O", columns=2),
23 | ).properties(
24 | width=200,
25 | height=100,
26 | )
27 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/boxplot.py:
--------------------------------------------------------------------------------
1 | """
2 | Boxplot with Min/Max Whiskers
3 | ------------------------------
4 | This example shows how to make a boxplot using US Population data from 2000.
5 | Note that the default value of the `extent` property is 1.5,
6 | which represents the convention of extending the whiskers
7 | to the furthest points within 1.5 * IQR from the first and third quartile.
8 | """
9 | # category: distributions
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.population.url
14 |
15 | alt.Chart(source).mark_boxplot(extent='min-max').encode(
16 | x='age:O',
17 | y='people:Q'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bubble_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Bubble Plot
3 | -----------------
4 | This example shows how to make a bubble plot.
5 | """
6 | # category: scatter plots
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | alt.Chart(source).mark_point().encode(
13 | x='Horsepower',
14 | y='Miles_per_Gallon',
15 | size='Acceleration'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/bump_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Bump Chart
3 | ----------
4 | This example shows a bump chart. The data is first grouped into six-month
5 | intervals using pandas. The ranks are computed by Altair using a
6 | window transform.
7 | """
8 | # category: line charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 | import pandas as pd
13 |
14 | stocks = data.stocks()
15 | source = stocks.groupby([pd.Grouper(key="date", freq="6MS"),"symbol"]).mean().reset_index()
16 |
17 | alt.Chart(source).mark_line(point = True).encode(
18 | x = alt.X("date:O", timeUnit="yearmonth", title="date"),
19 | y="rank:O",
20 | color=alt.Color("symbol:N")
21 | ).transform_window(
22 | rank="rank()",
23 | sort=[alt.SortField("price", order="descending")],
24 | groupby=["date"]
25 | ).properties(
26 | title="Bump Chart for Stock Prices",
27 | width=600,
28 | height=150,
29 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/choropleth.py:
--------------------------------------------------------------------------------
1 | """
2 | Choropleth Map
3 | ==============
4 | A choropleth map of unemployment rate per county in the US
5 | """
6 | # category: maps
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | counties = alt.topo_feature(data.us_10m.url, 'counties')
11 | source = data.unemployment.url
12 |
13 | alt.Chart(counties).mark_geoshape().encode(
14 | color='rate:Q'
15 | ).transform_lookup(
16 | lookup='id',
17 | from_=alt.LookupData(source, 'id', ['rate'])
18 | ).project(
19 | type='albersUsa'
20 | ).properties(
21 | width=500,
22 | height=300
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/choropleth_repeat.py:
--------------------------------------------------------------------------------
1 | """
2 | Repeated Choropleth Map
3 | =======================
4 | Three choropleths representing disjoint data from the same table.
5 | """
6 | # category: maps
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | states = alt.topo_feature(data.us_10m.url, 'states')
11 | source = data.population_engineers_hurricanes.url
12 | variable_list = ['population', 'engineers', 'hurricanes']
13 |
14 | alt.Chart(states).mark_geoshape().encode(
15 | alt.Color(alt.repeat('row'), type='quantitative')
16 | ).transform_lookup(
17 | lookup='id',
18 | from_=alt.LookupData(source, 'id', variable_list)
19 | ).properties(
20 | width=500,
21 | height=300
22 | ).project(
23 | type='albersUsa'
24 | ).repeat(
25 | row=variable_list
26 | ).resolve_scale(
27 | color='independent'
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/cumulative_count_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Cumulative Count Chart
3 | ----------------------
4 | This example shows an area chart with cumulative count.
5 | Adapted from https://vega.github.io/vega-lite/examples/area_cumulative_freq.html
6 |
7 | """
8 | # category: distributions
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.movies.url
14 |
15 | alt.Chart(source).transform_window(
16 | cumulative_count="count()",
17 | sort=[{"field": "IMDB_Rating"}],
18 | ).mark_area().encode(
19 | x="IMDB_Rating:Q",
20 | y=alt.Y("cumulative_count:Q", stack=False)
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/density_repeat.py:
--------------------------------------------------------------------------------
1 | """
2 | Repeated Density Estimates
3 | --------------------------
4 | Density estimates for each feature of iris flower.
5 | This is what we call a "repeated" plot, with one subplot
6 | for each feature.
7 | """
8 | # category: distributions
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.iris()
14 |
15 | alt.Chart(source).transform_fold(
16 | [
17 | "petalWidth",
18 | "petalLength",
19 | "sepalWidth",
20 | "sepalLength",
21 | ],
22 | as_=["Measurement_type", "value"],
23 | ).transform_density(
24 | density="value",
25 | bandwidth=0.3,
26 | groupby=["Measurement_type"],
27 | extent=[0, 8],
28 | ).mark_area().encode(
29 | alt.X("value:Q"),
30 | alt.Y("density:Q"),
31 | alt.Row("Measurement_type:N"),
32 | ).properties(
33 | width=300, height=50
34 | )
35 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/density_stack.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Density Estimates
3 | -------------------------
4 | To plot a stacked graph of estimates, use a shared ``extent`` and a fixed
5 | number of subdivision ``steps`` to ensure that the points for each area align
6 | well. Density estimates of measurements for each iris flower feature are plot
7 | in a stacked method. In addition, setting ``counts`` to true multiplies the
8 | densities by the number of data points in each group, preserving proportional
9 | differences.
10 | """
11 | # category: distributions
12 |
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.iris()
17 |
18 | alt.Chart(source).transform_fold(
19 | ['petalWidth',
20 | 'petalLength',
21 | 'sepalWidth',
22 | 'sepalLength'],
23 | as_ = ['Measurement_type', 'value']
24 | ).transform_density(
25 | density='value',
26 | bandwidth=0.3,
27 | groupby=['Measurement_type'],
28 | extent= [0, 8],
29 | counts = True,
30 | steps=200
31 | ).mark_area().encode(
32 | alt.X('value:Q'),
33 | alt.Y('density:Q', stack='zero'),
34 | alt.Color('Measurement_type:N')
35 | ).properties(width=400, height=100)
36 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/distributions_faceted_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Histogram
3 | -----------------
4 | This example shows how to make a basic faceted histogram,
5 | with one histogram subplot for different subsets of the data.
6 |
7 | Based off the vega-lite example:
8 | https://vega.github.io/vega-lite/examples/trellis_bar_histogram.html
9 | """
10 | # category: distributions
11 | import altair as alt
12 | from vega_datasets import data
13 |
14 | source = data.cars()
15 |
16 | alt.Chart(source).mark_bar().encode(
17 | alt.X("Horsepower:Q", bin=True),
18 | y="count()",
19 | row="Origin",
20 | )
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/donut_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Donut Chart
3 | -----------
4 | This example shows how to make a Donut Chart using ``mark_arc``.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Donut Chart <https://vega.github.io/vega-lite/examples/arc_donut.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({"category": [1, 2, 3, 4, 5, 6], "value": [4, 6, 10, 3, 7, 8]})
14 |
15 | alt.Chart(source).mark_arc(innerRadius=50).encode(
16 | theta=alt.Theta(field="value", type="quantitative"),
17 | color=alt.Color(field="category", type="nominal"),
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/empirical_cumulative_distribution_function.py:
--------------------------------------------------------------------------------
1 | """
2 | Empirical Cumulative Distribution Function
3 | ------------------------------------------
4 | This example shows an empirical cumulative distribution function.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | alt.Chart(source).transform_window(
13 | ecdf="cume_dist()",
14 | sort=[{"field": "IMDB_Rating"}],
15 | ).mark_line(
16 | interpolate="step-after"
17 | ).encode(
18 | x="IMDB_Rating:Q",
19 | y="ecdf:Q"
20 | )
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/errorbars_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Error Bars with Confidence Interval
3 | ======================================
4 | This example shows how to show error bars using confidence intervals.
5 | The confidence intervals are computed internally in vega by a non-parametric
6 | `bootstrap of the mean <https://github.com/vega/vega-statistics/blob/master/src/bootstrapCI.js>`_.
7 | """
8 | # category: uncertainties and trends
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.barley()
13 |
14 | error_bars = alt.Chart(source).mark_errorbar(extent='ci').encode(
15 | x=alt.X('yield:Q', scale=alt.Scale(zero=False)),
16 | y=alt.Y('variety:N')
17 | )
18 |
19 | points = alt.Chart(source).mark_point(filled=True, color='black').encode(
20 | x=alt.X('yield:Q', aggregate='mean'),
21 | y=alt.Y('variety:N'),
22 | )
23 |
24 | error_bars + points
25 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/errorbars_with_std.py:
--------------------------------------------------------------------------------
1 | """
2 | Error Bars with Standard Deviation
3 | ----------------------------------
4 | This example shows how to show error bars with standard deviation using crop yields data of different
5 | in the years of 1930s.
6 | """
7 | # category: uncertainties and trends
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.barley()
12 |
13 | error_bars = alt.Chart(source).mark_errorbar(extent='stdev').encode(
14 | x=alt.X('yield:Q', scale=alt.Scale(zero=False)),
15 | y=alt.Y('variety:N')
16 | )
17 |
18 | points = alt.Chart(source).mark_point(filled=True, color='black').encode(
19 | x=alt.X('yield:Q', aggregate='mean'),
20 | y=alt.Y('variety:N'),
21 | )
22 |
23 | error_bars + points
24 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/filled_step_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Filled Step Chart
3 | -----------------
4 | This example shows Google's stock price over time as a step chart with its area filled in and its line emphasized.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.stocks()
11 |
12 | alt.Chart(source).mark_area(
13 | color="lightblue",
14 | interpolate='step-after',
15 | line=True
16 | ).encode(
17 | x='date',
18 | y='price'
19 | ).transform_filter(alt.datum.symbol == 'GOOG')
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/gantt_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Gantt Chart
3 | -----------------
4 | This example shows how to make a simple Gantt chart.
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame([
11 | {"task": "A", "start": 1, "end": 3},
12 | {"task": "B", "start": 3, "end": 8},
13 | {"task": "C", "start": 8, "end": 10}
14 | ])
15 |
16 | alt.Chart(source).mark_bar().encode(
17 | x='start',
18 | x2='end',
19 | y='task'
20 | )
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/gapminder_bubble_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Gapminder Bubble Plot
3 | =====================
4 | This example shows how to make a bubble plot showing the correlation between
5 | health and income for 187 countries in the world (modified from an example
6 | in Lisa Charlotte Rost's blog post `'One Chart, Twelve Charting Libraries' <http://lisacharlotterost.github.io/2016/05/17/one-chart-code/>`_.
7 | """
8 | # category: case studies
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.gapminder_health_income.url
13 |
14 | alt.Chart(source).mark_circle().encode(
15 | alt.X('income:Q', scale=alt.Scale(type='log')),
16 | alt.Y('health:Q', scale=alt.Scale(zero=False)),
17 | size='population:Q'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/groupby-map.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Points with Proportional Symbols Map
3 | ============================================
4 | This is a layered geographic visualization that groups points by state.
5 | """
6 | # category: maps
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | airports = data.airports.url
11 | states = alt.topo_feature(data.us_10m.url, feature='states')
12 |
13 | # US states background
14 | background = alt.Chart(states).mark_geoshape(
15 | fill='lightgray',
16 | stroke='white'
17 | ).properties(
18 | width=500,
19 | height=300
20 | ).project('albersUsa')
21 |
22 | # Airports grouped by state
23 | points = alt.Chart(airports).transform_aggregate(
24 | latitude='mean(latitude)',
25 | longitude='mean(longitude)',
26 | count='count()',
27 | groupby=['state']
28 | ).mark_circle().encode(
29 | longitude='longitude:Q',
30 | latitude='latitude:Q',
31 | size=alt.Size('count:Q', title='Number of Airports'),
32 | color=alt.value('steelblue'),
33 | tooltip=['state:N','count:Q']
34 | ).properties(
35 | title='Number of airports in US'
36 | )
37 |
38 | background + points
39 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/grouped_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart
3 | -----------------
4 | This example shows a grouped bar chart.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='year:O',
14 | y='sum(yield):Q',
15 | color='year:N',
16 | column='site:N'
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/grouped_bar_chart2.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with xOffset
3 | ------------------------------
4 | Like :ref:`gallery_grouped_bar_chart`, this example shows a grouped bar chart. Whereas :ref:`gallery_grouped_bar_chart` used the ``column`` encoding channel, this example uses the ``xOffset`` encoding channel. This is adapted from a corresponding Vega-Lite Example:
5 | `Grouped Bar Chart <https://vega.github.io/vega-lite/examples/bar_grouped.html>`_.
6 | """
7 | # category: bar charts
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame({"Category":list("AAABBBCCC"),
12 | "Group":list("xyzxyzxyz"),
13 | "Value":[0.1, 0.6, 0.9, 0.7, 0.2, 1.1, 0.6, 0.1, 0.2]})
14 |
15 | alt.Chart(source).mark_bar().encode(
16 | x="Category:N",
17 | y="Value:Q",
18 | xOffset="Group:N",
19 | color="Group:N"
20 | )
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/grouped_bar_chart_horizontal.py:
--------------------------------------------------------------------------------
1 | """
2 | Horizontal Grouped Bar Chart
3 | ----------------------------
4 | This example shows a horizontal grouped bar chart.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield):Q',
14 | y='year:O',
15 | color='year:N',
16 | row='site:N'
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/grouped_bar_chart_overlapping_bars.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with xOffset and overlapping bars
3 | ---------------------------------------------------
4 | Like :ref:`gallery_grouped_bar_chart2`, this example shows a grouped bar chart using the ``xOffset`` encoding channel, but in this example the bars are partly overlapping within each group.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame(
11 | {
12 | "category": list("AABBCC"),
13 | "group": list("xyxyxy"),
14 | "value": [0.1, 0.6, 0.7, 0.2, 0.6, 0.1],
15 | }
16 | )
17 |
18 | base = alt.Chart(source, width=alt.Step(12)).encode(
19 | x="category:N",
20 | y="value:Q",
21 | xOffset=alt.XOffset("group:N", scale=alt.Scale(paddingOuter=0.5)),
22 | )
23 |
24 | alt.layer(
25 | base.mark_bar(size=20, stroke="white", fillOpacity=0.9).encode(fill="group:N"),
26 | base.mark_text(dy=-5).encode(text="value:Q"),
27 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/grouped_bar_chart_with_error_bars.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with Error Bars
3 | ---------------------------------
4 | This example shows a grouped bar chart with error bars.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | bars = alt.Chart().mark_bar().encode(
13 | x='year:O',
14 | y=alt.Y('mean(yield):Q', title='Mean Yield'),
15 | color='year:N',
16 | )
17 |
18 | error_bars = alt.Chart().mark_errorbar(extent='ci').encode(
19 | x='year:O',
20 | y='yield:Q'
21 | )
22 |
23 | alt.layer(bars, error_bars, data=source).facet(
24 | column='site:N'
25 | )
26 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/histogram_gradient_color.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with Gradient Color
3 | -----------------------------
4 | This example shows how to make a histogram with gradient color.
5 | The low-high IMDB rating is represented with the color scheme `pinkyellowgreen`.
6 | """
7 | # category: distributions
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.movies.url
12 |
13 | alt.Chart(source).mark_bar().encode(
14 | alt.X("IMDB_Rating:Q",
15 | bin=alt.Bin(maxbins=20),
16 | scale=alt.Scale(domain=[1, 10])
17 | ),
18 | alt.Y('count()'),
19 | alt.Color("IMDB_Rating:Q",
20 | bin=alt.Bin(maxbins=20),
21 | scale=alt.Scale(scheme='pinkyellowgreen')
22 | )
23 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/histogram_heatmap.py:
--------------------------------------------------------------------------------
1 | """
2 | 2D Histogram Heatmap
3 | --------------------
4 | This example shows how to make a heatmap from binned quantitative data.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | alt.Chart(source).mark_rect().encode(
13 | alt.X('IMDB_Rating:Q', bin=alt.Bin(maxbins=60)),
14 | alt.Y('Rotten_Tomatoes_Rating:Q', bin=alt.Bin(maxbins=40)),
15 | alt.Color('count():Q', scale=alt.Scale(scheme='greenblue'))
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/histogram_responsive.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with Responsive Bins
3 | ------------------------------
4 | This shows an example of a histogram with bins that are responsive to a
5 | selection domain. Click and drag on the bottom panel to see the bins
6 | change on the top panel.
7 | """
8 | # category: distributions
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.flights_5k.url
13 |
14 | brush = alt.selection_interval(encodings=['x'])
15 |
16 | base = alt.Chart(source).transform_calculate(
17 | time="hours(datum.date) + minutes(datum.date) / 60"
18 | ).mark_bar().encode(
19 | y='count():Q'
20 | ).properties(
21 | width=600,
22 | height=100
23 | )
24 |
25 | alt.vconcat(
26 | base.encode(
27 | alt.X('time:Q',
28 | bin=alt.Bin(maxbins=30, extent=brush),
29 | scale=alt.Scale(domain=brush)
30 | )
31 | ),
32 | base.encode(
33 | alt.X('time:Q', bin=alt.Bin(maxbins=30)),
34 | ).add_params(brush)
35 | )
36 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/histogram_scatterplot.py:
--------------------------------------------------------------------------------
1 | """
2 | 2D Histogram Scatter Plot
3 | -------------------------
4 | This example shows how to make a 2d histogram scatter plot.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | alt.X('IMDB_Rating:Q', bin=True),
14 | alt.Y('Rotten_Tomatoes_Rating:Q', bin=True),
15 | size='count()'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/histogram_with_a_global_mean_overlay.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with a Global Mean Overlay
3 | ------------------------------------
4 | This example shows a histogram with a global mean overlay.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | base = alt.Chart(source)
13 |
14 | bar = base.mark_bar().encode(
15 | x=alt.X('IMDB_Rating:Q', bin=True, axis=None),
16 | y='count()'
17 | )
18 |
19 | rule = base.mark_rule(color='red').encode(
20 | x='mean(IMDB_Rating):Q',
21 | size=alt.value(5)
22 | )
23 |
24 | bar + rule
25 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/horizontal_stacked_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Horizontal Stacked Bar Chart
3 | ============================
4 | This is an example of a horizontal stacked bar chart using data which contains crop yields over different regions and different years in the 1930s.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield)',
14 | y='variety',
15 | color='site'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/interactive_brush.py:
--------------------------------------------------------------------------------
1 | """
2 | Interactive Rectangular Brush
3 | =============================
4 | This example shows how to add a simple rectangular brush to a scatter plot.
5 | By clicking and dragging on the plot, you can highlight points within the
6 | range.
7 | """
8 | # category: interactive charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.cars()
13 | brush = alt.selection_interval()
14 |
15 | alt.Chart(source).mark_point().encode(
16 | x='Horsepower:Q',
17 | y='Miles_per_Gallon:Q',
18 | color=alt.when(brush).then("Cylinders:O").otherwise(alt.value("grey")),
19 | ).add_params(brush)
20 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/interactive_legend.py:
--------------------------------------------------------------------------------
1 | """
2 | Interactive Legend
3 | ------------------
4 | The following shows how to create a chart with an interactive legend, by
5 | binding the selection to ``"legend"``. Such a binding only works with
6 | ``selection_point`` when projected over a single field or encoding.
7 | """
8 | # category: interactive charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.unemployment_across_industries.url
13 |
14 | selection = alt.selection_point(fields=['series'], bind='legend')
15 |
16 | alt.Chart(source).mark_area().encode(
17 | alt.X('yearmonth(date):T', axis=alt.Axis(domain=False, format='%Y', tickSize=0)),
18 | alt.Y('sum(count):Q', stack='center', axis=None),
19 | alt.Color('series:N', scale=alt.Scale(scheme='category20b')),
20 | opacity=alt.when(selection).then(alt.value(1)).otherwise(alt.value(0.2))
21 | ).add_params(
22 | selection
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/interactive_reorder_stacked_bars.py:
--------------------------------------------------------------------------------
1 | """
2 | Reorder stacked bar segments
3 | ============================
4 | This example uses a calculate transform
5 | to check the values of the "site" column
6 | vs the clicked values in the legend,
7 | and assigns a lower order (0)
8 | if there is a match.
9 | The use of "indexOf" checks for equality in an array,
10 | which here allows for multiple segments to be reordered
11 | by holding down the shift key while clicking the legend.
12 | """
13 | # category: interactive charts
14 | import altair as alt
15 | from vega_datasets import data
16 |
17 | selection = alt.selection_point(fields=['site'], bind='legend')
18 |
19 | source = data.barley.url
20 |
21 | alt.Chart(source).mark_bar().transform_calculate(
22 | site_order=f"if({selection.name}.site && indexof({selection.name}.site, datum.site) !== -1, 0, 1)"
23 | ).encode(
24 | x='sum(yield):Q',
25 | y='variety:N',
26 | color='site:N',
27 | order='site_order:N',
28 | opacity=alt.when(selection).then(alt.value(0.9)).otherwise(alt.value(0.2))
29 | ).add_params(
30 | selection
31 | )
32 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/interactive_scatter_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Interactive Colored Scatter Plot
3 | ---------------------------------------
4 | This example shows how to make an interactive scatter plot.
5 | """
6 | # category: interactive charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | x='Horsepower',
14 | y='Miles_per_Gallon',
15 | color='Origin',
16 | ).interactive()
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/interval_selection.py:
--------------------------------------------------------------------------------
1 | """
2 | Interval Selection with Initial Date Range
3 | ==========================================
4 |
5 | This is an example of creating a stacked chart for which the domain of the
6 | top chart can be selected by interacting with the bottom chart. The initial
7 | selection range is set using Python's native datetime objects.
8 | """
9 | # category: interactive charts
10 | import altair as alt
11 | from vega_datasets import data
12 | import datetime as dt
13 |
14 | source = data.sp500.url
15 |
16 | date_range = (dt.date(2007, 6, 30), dt.date(2009, 6, 30))
17 |
18 | brush = alt.selection_interval(encodings=['x'],
19 | value={'x': date_range})
20 |
21 | base = alt.Chart(source).mark_area().encode(
22 | x = 'date:T',
23 | y = 'price:Q'
24 | ).properties(
25 | width=600,
26 | height=200
27 | )
28 |
29 | upper = base.encode(
30 | alt.X('date:T', scale=alt.Scale(domain=brush))
31 | )
32 |
33 | lower = base.properties(
34 | height=60
35 | ).add_params(brush)
36 |
37 | upper & lower
38 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/iowa_electricity.py:
--------------------------------------------------------------------------------
1 | """
2 | Iowa's Renewable Energy Boom
3 | ----------------------------
4 | This example is a fully developed stacked chart using the sample dataset of Iowa's electricity sources.
5 | """
6 | # category: case studies
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source, title="Iowa's renewable energy boom").mark_area().encode(
13 | x=alt.X(
14 | "year:T",
15 | title="Year"
16 | ),
17 | y=alt.Y(
18 | "net_generation:Q",
19 | stack="normalize",
20 | title="Share of net generation",
21 | axis=alt.Axis(format=".0%"),
22 | ),
23 | color=alt.Color(
24 | "source:N",
25 | legend=alt.Legend(title="Electricity source"),
26 | )
27 | )
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/isotype_grid.py:
--------------------------------------------------------------------------------
1 | """
2 | Isotype Grid
3 | ------------
4 | This example is a grid of isotype figures.
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | import pandas as pd
9 |
10 | data = pd.DataFrame([dict(id=i) for i in range(1, 101)])
11 |
12 | person = (
13 | "M1.7 -1.7h-0.8c0.3 -0.2 0.6 -0.5 0.6 -0.9c0 -0.6 "
14 | "-0.4 -1 -1 -1c-0.6 0 -1 0.4 -1 1c0 0.4 0.2 0.7 0.6 "
15 | "0.9h-0.8c-0.4 0 -0.7 0.3 -0.7 0.6v1.9c0 0.3 0.3 0.6 "
16 | "0.6 0.6h0.2c0 0 0 0.1 0 0.1v1.9c0 0.3 0.2 0.6 0.3 "
17 | "0.6h1.3c0.2 0 0.3 -0.3 0.3 -0.6v-1.8c0 0 0 -0.1 0 "
18 | "-0.1h0.2c0.3 0 0.6 -0.3 0.6 -0.6v-2c0.2 -0.3 -0.1 "
19 | "-0.6 -0.4 -0.6z"
20 | )
21 |
22 | alt.Chart(data).transform_calculate(
23 | row="ceil(datum.id/10)"
24 | ).transform_calculate(
25 | col="datum.id - datum.row*10"
26 | ).mark_point(
27 | filled=True,
28 | size=50
29 | ).encode(
30 | x=alt.X("col:O", axis=None),
31 | y=alt.Y("row:O", axis=None),
32 | shape=alt.ShapeValue(person)
33 | ).properties(
34 | width=400,
35 | height=400
36 | ).configure_view(
37 | strokeWidth=0
38 | )
39 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/lasagna_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Lasagna Plot (Dense Time-Series Heatmap)
3 | ----------------------------------------
4 | """
5 | # category: tables
6 | import altair as alt
7 | from vega_datasets import data
8 |
9 | source = data.stocks()
10 |
11 | color_condition = (
12 | alt.when(alt.expr.month("datum.value") == 1, alt.expr.date("datum.value") == 1)
13 | .then(alt.value("black"))
14 | .otherwise(alt.value(None))
15 | )
16 |
17 | alt.Chart(source, width=300, height=100).transform_filter(
18 | alt.datum.symbol != "GOOG"
19 | ).mark_rect().encode(
20 | x=alt.X(
21 | "yearmonthdate(date):O",
22 | axis=alt.Axis(
23 | format="%Y",
24 | labelAngle=0,
25 | labelOverlap=False,
26 | labelColor=color_condition,
27 | tickColor=color_condition,
28 | ),
29 | title="Time",
30 | ),
31 | y=alt.Y("symbol:N", title=None),
32 | color=alt.Color("sum(price)", title="Price"),
33 | )
34 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layer_line_color_rule.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Layered Aggregates
3 | ----------------------------------
4 | This example shows how to make a multi-series line chart of the daily closing
5 | stock prices for AAPL, AMZN, GOOG, IBM, and MSFT between 2000 and 2010, along
6 | with a layered rule showing the average values.
7 | """
8 | # category: line charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.stocks()
13 |
14 | base = alt.Chart(source).properties(width=550)
15 |
16 | line = base.mark_line().encode(
17 | x='date',
18 | y='price',
19 | color='symbol'
20 | )
21 |
22 | rule = base.mark_rule().encode(
23 | y='average(price)',
24 | color='symbol',
25 | size=alt.value(2)
26 | )
27 |
28 | line + rule
29 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_area_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Area Chart
3 | ------------------
4 | This example shows a layered area chart.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_area(opacity=0.3).encode(
13 | x="year:T",
14 | y=alt.Y("net_generation:Q", stack=None),
15 | color="source:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Bar Chart
3 | -----------------
4 | This example shows a segmented bar chart that is layered rather than stacked.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_bar(opacity=0.7).encode(
13 | x='year:O',
14 | y=alt.Y('net_generation:Q', stack=None),
15 | color="source",
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_chart_bar_mark.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar and Tick Chart
3 | ------------------
4 | How to layer a tick chart on top of a bar chart.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame({
11 | 'project': ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
12 | 'score': [25, 57, 23, 19, 8, 47, 8],
13 | 'goal': [25, 47, 30, 27, 38, 19, 4]
14 | })
15 |
16 | bar = alt.Chart(source).mark_bar().encode(
17 | x='project',
18 | y='score'
19 | ).properties(
20 | width=alt.Step(40) # controls width of bar.
21 | )
22 |
23 | tick = alt.Chart(source).mark_tick(
24 | color='red',
25 | thickness=2,
26 | size=40 * 0.9, # controls width of tick.
27 | ).encode(
28 | x='project',
29 | y='goal'
30 | )
31 |
32 | bar + tick
33 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_chart_with_dual_axis.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered chart with Dual-Axis
3 | ----------------------------
4 | This example shows how to create a second independent y axis.
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.seattle_weather()
12 |
13 | base = alt.Chart(source).encode(
14 | alt.X('month(date):T', axis=alt.Axis(title=None))
15 | )
16 |
17 | area = base.mark_area(opacity=0.3, color='#57A44C').encode(
18 | alt.Y('average(temp_max)',
19 | axis=alt.Axis(title='Avg. Temperature (°C)', titleColor='#57A44C')),
20 | alt.Y2('average(temp_min)')
21 | )
22 |
23 | line = base.mark_line(stroke='#5276A7', interpolate='monotone').encode(
24 | alt.Y('average(precipitation)',
25 | axis=alt.Axis(title='Precipitation (inches)', titleColor='#5276A7'))
26 | )
27 |
28 | alt.layer(area, line).resolve_scale(
29 | y = 'independent'
30 | )
31 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_heatmap_text.py:
--------------------------------------------------------------------------------
1 | """
2 | Text over a Heatmap
3 | -------------------
4 |
5 | An example of a layered chart of text over a heatmap using the cars dataset.
6 | """
7 | # category: tables
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.cars()
12 |
13 | # Configure common options. We specify the aggregation
14 | # as a transform here so we can reuse it in both layers.
15 | base = alt.Chart(source).transform_aggregate(
16 | mean_horsepower='mean(Horsepower)',
17 | groupby=['Origin', 'Cylinders']
18 | ).encode(
19 | alt.X('Cylinders:O'),
20 | alt.Y('Origin:O'),
21 | )
22 |
23 | # Configure heatmap
24 | heatmap = base.mark_rect().encode(
25 | color=alt.Color('mean_horsepower:Q',
26 | scale=alt.Scale(scheme='viridis'),
27 | legend=alt.Legend(title="Mean of Horsepower"),
28 | )
29 | )
30 |
31 | color = (
32 | alt.when(alt.datum.mean_horsepower > 150)
33 | .then(alt.value("black"))
34 | .otherwise(alt.value("white"))
35 | )
36 | # Configure text
37 | text = base.mark_text(baseline='middle').encode(
38 | text=alt.Text('mean_horsepower:Q', format=".0f"), color=color
39 | )
40 |
41 | # Draw the chart
42 | heatmap + text
43 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/layered_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Histogram
3 | =================
4 | This example shows how to use opacity to make a layered histogram in Altair.
5 | """
6 | # category: distributions
7 | import pandas as pd
8 | import altair as alt
9 | import numpy as np
10 | np.random.seed(42)
11 |
12 | # Generating Data
13 | source = pd.DataFrame({
14 | 'Trial A': np.random.normal(0, 0.8, 1000),
15 | 'Trial B': np.random.normal(-2, 1, 1000),
16 | 'Trial C': np.random.normal(3, 2, 1000)
17 | })
18 |
19 | alt.Chart(source).transform_fold(
20 | ['Trial A', 'Trial B', 'Trial C'],
21 | as_=['Experiment', 'Measurement']
22 | ).mark_bar(
23 | opacity=0.3,
24 | binSpacing=0
25 | ).encode(
26 | alt.X('Measurement:Q', bin=alt.Bin(maxbins=100)),
27 | alt.Y('count()', stack=None),
28 | alt.Color('Experiment:N')
29 | )
30 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_color_datum.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Datum for Color
3 | -------------------------------
4 | An example of using ``datum`` and ``repeat`` to color a multi-series line chart.
5 | This is adapted from this corresponding Vega-Lite Example:
6 | `Repeat and Layer to Show Different Movie Measures <https://vega.github.io/vega-lite/examples/repeat_layer.html>`_.
7 | """
8 | # category: line charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.movies()
14 |
15 | alt.Chart(source).mark_line().encode(
16 | x=alt.X("IMDB_Rating", bin=True),
17 | y=alt.Y(
18 | alt.repeat("layer"), aggregate="mean", title="Mean of US and Worldwide Gross"
19 | ),
20 | color=alt.datum(alt.repeat("layer")),
21 | ).repeat(layer=["US_Gross", "Worldwide_Gross"])
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_cumsum.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Cumulative Sum
3 | ------------------------------
4 | This chart creates a simple line chart from the cumulative sum of a fields.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | alt.Chart(source).mark_line().transform_window(
13 | # Sort the data chronologically
14 | sort=[{'field': 'year'}],
15 | # Include all previous records before the current record and none after
16 | # (This is the default value so you could skip it and it would still work.)
17 | frame=[None, 0],
18 | # What to add up as you go
19 | cumulative_wheat='sum(wheat)'
20 | ).encode(
21 | x='year:O',
22 | # Plot the calculated field created by the transformation
23 | y='cumulative_wheat:Q'
24 | ).properties(width=600)
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_custom_legend.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Custom Legend
3 | -----------------------------
4 | This example uses the argmax aggregation function in order to create a custom
5 | legend for a line chart.
6 | """
7 | # category: line charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 |
12 | source = data.stocks()
13 |
14 | base = alt.Chart(source).encode(
15 | color=alt.Color("symbol", legend=None)
16 | ).transform_filter(
17 | "datum.symbol !== 'IBM'"
18 | ).properties(
19 | width=500
20 | )
21 |
22 | line = base.mark_line().encode(x="date", y="price")
23 |
24 |
25 | last_price = base.mark_circle().encode(
26 | x=alt.X("last_date['date']:T"),
27 | y=alt.Y("last_date['price']:Q")
28 | ).transform_aggregate(
29 | last_date="argmax(date)",
30 | groupby=["symbol"]
31 | )
32 |
33 | company_name = last_price.mark_text(align="left", dx=4).encode(text="symbol")
34 |
35 | chart = (line + last_price + company_name).encode(
36 | x=alt.X(title="date"),
37 | y=alt.Y(title="price")
38 | )
39 |
40 | chart
41 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_datum.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Datum
3 | ---------------------------------
4 | An example of using ``datum`` to highlight certain values, including a ``DateTime`` value.
5 | This is adapted from two corresponding Vega-Lite Examples:
6 | `Highlight a Specific Value <https://vega.github.io/vega-lite/docs/datum.html#highlight-a-specific-data-value>`_.
7 | """
8 | # category: line charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.stocks()
14 |
15 | lines = (
16 | alt.Chart(source)
17 | .mark_line()
18 | .encode(x="date", y="price", color="symbol")
19 | )
20 |
21 | xrule = (
22 | alt.Chart()
23 | .mark_rule(color="cyan", strokeWidth=2)
24 | .encode(x=alt.datum(alt.DateTime(year=2006, month="November")))
25 | )
26 |
27 | yrule = (
28 | alt.Chart().mark_rule(strokeDash=[12, 6], size=2).encode(y=alt.datum(350))
29 | )
30 |
31 |
32 | lines + yrule + xrule
33 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_generator.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Sequence Generator
3 | ----------------------------------
4 | This examples shows how to create multiple lines using the sequence generator.
5 | """
6 | # category: line charts
7 |
8 | import altair as alt
9 |
10 | source = alt.sequence(start=0, stop=12.7, step=0.1, as_='x')
11 |
12 | alt.Chart(source).mark_line().transform_calculate(
13 | sin='sin(datum.x)',
14 | cos='cos(datum.x)'
15 | ).transform_fold(
16 | ['sin', 'cos']
17 | ).encode(
18 | x='x:Q',
19 | y='value:Q',
20 | color='key:N'
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_interpolation.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Interpolation
3 | -----------------------------
4 | This chart shows a line chart with the path interpolated. A full list of interpolation methods is available `in the documentation <https://altair-viz.github.io/user_guide/generated/core/altair.LineConfig.html?highlight=interpolate#altair-lineconfig>`_.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.stocks()
11 |
12 | alt.Chart(source).mark_line(interpolate="monotone").encode(
13 | x="date:T",
14 | y="price:Q",
15 | color="symbol:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_points.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Point Markers
3 | -----------------------------
4 | This chart shows a simple line chart with points marking each value.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.stocks()
11 |
12 | alt.Chart(source).mark_line(point=True).encode(
13 | x='date:T',
14 | y='price:Q',
15 | color='symbol:N'
16 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_chart_with_points_stroked.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Stroked Point Markers
3 | -------------------------------------
4 | This example shows a simple line chart with points in a different color.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.stocks()
11 |
12 | alt.Chart(source).mark_line(
13 | point=alt.OverlayMarkDef(filled=False, fill="white")
14 | ).encode(
15 | x='date:T',
16 | y='price:Q',
17 | color='symbol:N'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_custom_order.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Custom Order
3 | ----------------------------
4 | By default, the line's path (order of points in the line) is
5 | determined by data values on the temporal/ordinal field.
6 | However, a field can be mapped to the order channel for a custom path.
7 |
8 | For example, to show a pattern of data change over time between
9 | gasoline price and average miles driven per capita we use
10 | order channel to sort the points in the line by time field (year).
11 | The earliest year (1956) is one endpoint and the latest year (2010)
12 | is the other endpoint.
13 |
14 | This is based on Hannah Fairfield's article 'Driving Shifts Into Reverse'.
15 | See https://archive.nytimes.com/www.nytimes.com/imagepages/2010/05/02/business/02metrics.html.
16 | """
17 | # category: line charts
18 | import altair as alt
19 | from vega_datasets import data
20 |
21 | source = data.driving()
22 |
23 | alt.Chart(source).mark_line(point=True).encode(
24 | alt.X("miles", scale=alt.Scale(zero=False)),
25 | alt.Y("gas", scale=alt.Scale(zero=False)),
26 | order="year",
27 | tooltip=["miles", "gas", "year"],
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_percent.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Percent axis
3 | ----------------------------
4 | This example shows how to format the tick labels of the y-axis of a chart as percentages.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.jobs.url
11 |
12 | alt.Chart(source).mark_line().encode(
13 | alt.X('year:O'),
14 | alt.Y('perc:Q', axis=alt.Axis(format='%')),
15 | color='sex:N'
16 | ).transform_filter(
17 | alt.datum.job == 'Welder'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Confidence Interval Band
3 | ----------------------------------------
4 | How to make a line chart with a bootstrapped 95% confidence interval band.
5 | """
6 | # category: uncertainties and trends
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | line = alt.Chart(source).mark_line().encode(
13 | x='Year',
14 | y='mean(Miles_per_Gallon)'
15 | )
16 |
17 | band = alt.Chart(source).mark_errorband(extent='ci').encode(
18 | x='Year',
19 | y=alt.Y('Miles_per_Gallon', title='Miles/Gallon'),
20 | )
21 |
22 | band + line
23 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_with_last_value_labeled.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Last Value Labeled
3 | ----------------------------------
4 | This chart shows a line chart with a label annotating the final value
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | # Import example data
11 | source = data.stocks()
12 |
13 | # Create a common chart object
14 | # Use `transform_filter` to reduce the dataset to clarify our example. Not required.
15 | chart = (
16 | alt.Chart(source)
17 | .transform_filter(alt.datum.symbol != "IBM")
18 | .encode(color=alt.Color("symbol", legend=None))
19 | )
20 |
21 | # Draw the line
22 | line = chart.mark_line().encode(x="date:T", y="price:Q")
23 |
24 | # Use the `argmax` aggregate to limit the dataset to the final value
25 | label = chart.encode(
26 | x=alt.X("max(date):T"),
27 | y=alt.Y("price:Q", aggregate=alt.ArgmaxDef(argmax="date")),
28 | text="symbol",
29 | )
30 |
31 | # Create a text label
32 | text = label.mark_text(align="left", dx=4)
33 |
34 | # Create a circle annotation
35 | circle = label.mark_circle()
36 |
37 | # Draw the chart with all the layers combined
38 | line + circle + text
39 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/line_with_log_scale.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Logarithmic Scale
3 | ---------------------------------
4 | How to make a line chart on a `Logarithmic scale <https://en.wikipedia.org/wiki/Logarithmic_scale>`_.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.population()
11 |
12 | alt.Chart(source).mark_line().encode(
13 | x='year:O',
14 | y=alt.Y(
15 | 'sum(people)',
16 | scale=alt.Scale(type="log") # Here the scale is applied
17 | )
18 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/multi_series_line.py:
--------------------------------------------------------------------------------
1 | """
2 | Multiple Series Line Chart
3 | --------------------------
4 |
5 | This example shows how to make a line chart with multiple series of data.
6 | """
7 | # category: line charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.stocks()
12 |
13 | alt.Chart(source).mark_line().encode(
14 | x='date:T',
15 | y='price:Q',
16 | color='symbol:N',
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/multifeature_scatter_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Multifeature Scatter Plot
3 | =========================
4 | This example shows how to make a scatter plot with multiple feature encodings.
5 | """
6 | # category: scatter plots
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iris()
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | alt.X('sepalLength', scale=alt.Scale(zero=False)),
14 | alt.Y('sepalWidth', scale=alt.Scale(zero=False, padding=1)),
15 | color='species',
16 | size='petalWidth'
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/multiline_highlight.py:
--------------------------------------------------------------------------------
1 | """
2 | Multi-Line Highlight
3 | ====================
4 | This multi-line chart uses an invisible Voronoi tessellation to handle pointerover to
5 | identify the nearest point and then highlight the line on which the point falls.
6 | It is adapted from the Vega-Lite example found at
7 | https://bl.ocks.org/amitkaps/fe4238e716db53930b2f1a70d3401701
8 | """
9 | # category: interactive charts
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.stocks()
14 |
15 | highlight = alt.selection_point(on='pointerover',
16 | fields=['symbol'], nearest=True)
17 |
18 | base = alt.Chart(source).encode(
19 | x='date:T',
20 | y='price:Q',
21 | color='symbol:N'
22 | )
23 |
24 | points = base.mark_circle().encode(
25 | opacity=alt.value(0)
26 | ).add_params(
27 | highlight
28 | ).properties(
29 | width=600
30 | )
31 |
32 | lines = base.mark_line().encode(
33 | size=alt.when(~highlight).then(alt.value(1)).otherwise(alt.value(3))
34 | )
35 |
36 | points + lines
37 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/normalized_stacked_area_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Normalized Stacked Area Chart
3 | -----------------------------
4 | This example shows how to make a normalized stacked area chart.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_area().encode(
13 | x="year:T",
14 | y=alt.Y("net_generation:Q", stack="normalize"),
15 | color="source:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/normalized_stacked_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Normalized Stacked Bar Chart
3 | ----------------------------
4 | This is an example of a normalized stacked bar chart using data which contains crop yields over different regions and different years in the 1930s.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x=alt.X('sum(yield)', stack="normalize"),
14 | y='variety',
15 | color='site'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/one_dot_per_zipcode.py:
--------------------------------------------------------------------------------
1 | """
2 | One Dot Per Zipcode
3 | -----------------------
4 | This example shows a geographical plot with one dot per zipcode.
5 | """
6 | # category: case studies
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | # Since the data is more than 5,000 rows we'll import it from a URL
11 | source = data.zipcodes.url
12 |
13 | alt.Chart(source).transform_calculate(
14 | "leading digit", alt.expr.substring(alt.datum.zip_code, 0, 1)
15 | ).mark_circle(size=3).encode(
16 | longitude='longitude:Q',
17 | latitude='latitude:Q',
18 | color='leading digit:N',
19 | tooltip='zip_code:N'
20 | ).project(
21 | type='albersUsa'
22 | ).properties(
23 | width=650,
24 | height=400
25 | )
26 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/pacman_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Pacman Chart
3 | ------------
4 | Chart made using ``mark_arc`` and constant values.
5 | This could also be made using
6 | ``alt.Chart(source).mark_arc(color = "gold", theta = (5/8)*np.pi, theta2 = (19/8)*np.pi,radius=100)``.
7 | """
8 | # category: circular plots
9 |
10 | import numpy as np
11 | import altair as alt
12 |
13 | alt.Chart().mark_arc(color="gold").encode(
14 | theta=alt.datum((5 / 8) * np.pi, scale=None),
15 | theta2=alt.datum((19 / 8) * np.pi),
16 | radius=alt.datum(100, scale=None),
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/parallel_coordinates.py:
--------------------------------------------------------------------------------
1 | """
2 | Parallel Coordinates
3 | --------------------
4 | A `Parallel Coordinates <https://en.wikipedia.org/wiki/Parallel_coordinates>`_
5 | chart is a chart that lets you visualize the individual data points by drawing
6 | a single line for each of them.
7 | Such a chart can be created in Altair by first transforming the data into a
8 | suitable representation.
9 | This example shows a parallel coordinates chart with the Iris dataset.
10 | """
11 | # category: advanced calculations
12 |
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.iris()
17 |
18 | alt.Chart(source).transform_window(
19 | index='count()'
20 | ).transform_fold(
21 | ['petalLength', 'petalWidth', 'sepalLength', 'sepalWidth']
22 | ).mark_line().encode(
23 | x='key:N',
24 | y='value:Q',
25 | color='species:N',
26 | detail='index:N',
27 | opacity=alt.value(0.5)
28 | ).properties(width=500)
29 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/percentage_of_total.py:
--------------------------------------------------------------------------------
1 | """
2 | Calculating Percentage of Total
3 | -------------------------------
4 | This chart demonstrates how to use a joinaggregate transform to display
5 | data values as a percentage of total.
6 | """
7 | # category: bar charts
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame({'Activity': ['Sleeping', 'Eating', 'TV', 'Work', 'Exercise'],
12 | 'Time': [8, 2, 4, 8, 2]})
13 |
14 | alt.Chart(source).transform_joinaggregate(
15 | TotalTime='sum(Time)',
16 | ).transform_calculate(
17 | PercentOfTotal="datum.Time / datum.TotalTime"
18 | ).mark_bar().encode(
19 | alt.X('PercentOfTotal:Q', axis=alt.Axis(format='.0%')),
20 | y='Activity:N'
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/pie_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Pie Chart
3 | ---------
4 | This example shows how to make a Pie Chart using ``mark_arc``.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Pie Chart <https://vega.github.io/vega-lite/examples/arc_pie.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({"category": [1, 2, 3, 4, 5, 6], "value": [4, 6, 10, 3, 7, 8]})
14 |
15 | alt.Chart(source).mark_arc().encode(
16 | theta=alt.Theta(field="value", type="quantitative"),
17 | color=alt.Color(field="category", type="nominal"),
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/pie_chart_with_labels.py:
--------------------------------------------------------------------------------
1 | """
2 | Pie Chart with Labels
3 | ---------------------
4 | This example shows how to layer text over arc marks (``mark_arc``) to label pie charts.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Pie Chart with Labels <https://vega.github.io/vega-lite/examples/layer_arc_label.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame(
14 | {"category": ["a", "b", "c", "d", "e", "f"], "value": [4, 6, 10, 3, 7, 8]}
15 | )
16 |
17 | base = alt.Chart(source).encode(
18 | theta=alt.Theta("value:Q", stack=True), color=alt.Color("category:N", legend=None)
19 | )
20 |
21 | pie = base.mark_arc(outerRadius=120)
22 | text = base.mark_text(radius=140, size=20).encode(text="category:N")
23 |
24 | pie + text
25 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/point_map.py:
--------------------------------------------------------------------------------
1 | """
2 | Point map
3 | =========
4 | This is a layered map that shows the positions of airports on a background of U.S. states.
5 | """
6 | # category: maps
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | # Read in points
11 | airports = data.airports()
12 |
13 | # Read in polygons from topojson
14 | states = alt.topo_feature(data.us_10m.url, feature='states')
15 |
16 | # US states background
17 | background = alt.Chart(states).mark_geoshape(
18 | fill='lightgray',
19 | stroke='white'
20 | ).properties(
21 | width=500,
22 | height=300
23 | ).project('albersUsa')
24 |
25 | # airport positions on background
26 | points = alt.Chart(airports).mark_circle(
27 | size=10,
28 | color='steelblue'
29 | ).encode(
30 | longitude='longitude:Q',
31 | latitude='latitude:Q',
32 | tooltip=['name', 'city', 'state']
33 | )
34 |
35 | background + points
36 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/poly_fit_regression.py:
--------------------------------------------------------------------------------
1 | """
2 | Polynomial Fit Plot with Regression Transform
3 | =============================================
4 | This example shows how to overlay data with multiple fitted polynomials using
5 | the regression transform.
6 | """
7 | # category: uncertainties and trends
8 |
9 | import numpy as np
10 | import pandas as pd
11 | import altair as alt
12 |
13 | # Generate some random data
14 | rng = np.random.RandomState(1)
15 | x = rng.rand(40) ** 2
16 | y = 10 - 1.0 / (x + 0.1) + rng.randn(40)
17 | source = pd.DataFrame({"x": x, "y": y})
18 |
19 | # Define the degree of the polynomial fits
20 | degree_list = [1, 3, 5]
21 |
22 | base = alt.Chart(source).mark_circle(color="black").encode(
23 | alt.X("x"), alt.Y("y")
24 | )
25 |
26 | polynomial_fit = [
27 | base.transform_regression(
28 | "x", "y", method="poly", order=order, as_=["x", str(order)]
29 | )
30 | .mark_line()
31 | .transform_fold([str(order)], as_=["degree", "y"])
32 | .encode(alt.Color("degree:N"))
33 | for order in degree_list
34 | ]
35 |
36 | alt.layer(base, *polynomial_fit)
37 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/pyramid.py:
--------------------------------------------------------------------------------
1 | """
2 | Pyramid Pie Chart
3 | -----------------
4 | Altair reproduction of http://robslink.com/SAS/democd91/pyramid_pie.htm
5 | """
6 | # category: case studies
7 | import altair as alt
8 | import pandas as pd
9 |
10 | category = ['Sky', 'Shady side of a pyramid', 'Sunny side of a pyramid']
11 | color = ["#416D9D", "#674028", "#DEAC58"]
12 | df = pd.DataFrame({'category': category, 'value': [75, 10, 15]})
13 |
14 | alt.Chart(df).mark_arc(outerRadius=80).encode(
15 | alt.Theta('value:Q', scale=alt.Scale(range=[2.356, 8.639])),
16 | alt.Color('category:N',
17 | scale=alt.Scale(domain=category, range=color),
18 | legend=alt.Legend(title=None, orient='none', legendX=160, legendY=50)),
19 | order='value:Q'
20 | ).properties(width=150, height=150).configure_view(strokeOpacity=0)
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/radial_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Radial Chart
3 | ------------
4 | This radial plot uses both angular and radial extent to convey multiple dimensions of data.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Radial Plot <https://vega.github.io/vega-lite/examples/arc_radial.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({"values": [12, 23, 47, 6, 52, 19]})
14 |
15 | base = alt.Chart(source).encode(
16 | theta=alt.Theta("values:Q", stack=True),
17 | radius=alt.Radius("values", scale=alt.Scale(type="sqrt", zero=True, rangeMin=20)),
18 | color="values:N",
19 | )
20 |
21 | c1 = base.mark_arc(innerRadius=20, stroke="#fff")
22 |
23 | c2 = base.mark_text(radiusOffset=10).encode(text="values:Q")
24 |
25 | c1 + c2
26 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/ranged_dot_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Ranged Dot Plot
3 | ---------------
4 | This example shows a ranged dot plot to convey changing life expectancy for the five most populous countries (between 1955 and 2000).
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.countries.url
11 |
12 | chart = (
13 | alt.Chart(source)
14 | .encode(x="life_expect:Q", y="country:N")
15 | .transform_filter(
16 | alt.FieldOneOfPredicate(
17 | field="country",
18 | oneOf=["China", "India", "United States", "Indonesia", "Brazil"],
19 | )
20 | )
21 | .transform_filter(alt.FieldOneOfPredicate(field="year", oneOf=[1955, 2000]))
22 | )
23 |
24 | line = chart.mark_line(color="#db646f").encode(detail="country:N")
25 |
26 | # Add points for life expectancy in 1955 & 2000
27 | color = alt.Color(
28 | "year:O", scale=alt.Scale(domain=[1955, 2000], range=["#e6959c", "#911a24"])
29 | )
30 | points = (
31 | chart.mark_point(
32 | size=100,
33 | opacity=1,
34 | filled=True,
35 | )
36 | .encode(color=color)
37 | .interactive()
38 | )
39 |
40 | (line + points)
41 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_faceted.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Scatter Plot
3 | --------------------
4 | A series of scatter plots, one for each country/area of origin.
5 | """
6 | # category: scatter plots
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | alt.Chart(source, width=100, height=100).mark_point().encode(
13 | x="Horsepower:Q",
14 | y="Miles_per_Gallon:Q",
15 | row="Origin:N",
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_href.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Plot with Href
3 | ----------------------
4 | This example shows a scatter plot with an ``href`` encoding constructed from
5 | the car name. With this encoding, you can click on any of the points to open
6 | a google search for the car name.
7 | """
8 | # category: scatter plots
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.cars()
14 |
15 | alt.Chart(source).transform_calculate(
16 | url='https://www.google.com/search?q=' + alt.datum.Name
17 | ).mark_point().encode(
18 | x='Horsepower:Q',
19 | y='Miles_per_Gallon:Q',
20 | color='Origin:N',
21 | href='url:N',
22 | tooltip=['Name:N', 'url:N']
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_linked_brush.py:
--------------------------------------------------------------------------------
1 | """
2 | Multi-panel Scatter Plot with Linked Brushing
3 | ---------------------------------------------
4 | This is an example of using an interval selection to control the color of
5 | points across multiple panels.
6 | """
7 | # category: interactive charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.cars()
12 |
13 | brush = alt.selection_interval(resolve='global')
14 |
15 | base = alt.Chart(source).mark_point().encode(
16 | y='Miles_per_Gallon',
17 | color=alt.when(brush).then("Origin").otherwise(alt.ColorValue("gray")),
18 | ).add_params(
19 | brush
20 | ).properties(
21 | width=250,
22 | height=250
23 | )
24 |
25 | base.encode(x='Horsepower') | base.encode(x='Acceleration')
26 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_matrix.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Matrix
3 | --------------
4 | An example of using a RepeatChart to construct a multi-panel scatter plot
5 | with linked panning and zooming.
6 | """
7 | # category: scatter plots
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.cars()
12 |
13 | alt.Chart(source).mark_circle().encode(
14 | alt.X(alt.repeat("column"), type='quantitative'),
15 | alt.Y(alt.repeat("row"), type='quantitative'),
16 | color='Origin:N'
17 | ).properties(
18 | width=150,
19 | height=150
20 | ).repeat(
21 | row=['Horsepower', 'Acceleration', 'Miles_per_Gallon'],
22 | column=['Miles_per_Gallon', 'Acceleration', 'Horsepower']
23 | ).interactive()
24 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_qq.py:
--------------------------------------------------------------------------------
1 | """
2 | Quantile-Quantile Plot
3 | ----------------------
4 | A quantile-quantile plot comparing input data to theoretical distributions.
5 | """
6 | # category: distributions
7 |
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.normal_2d.url
12 |
13 | base = alt.Chart(source).transform_quantile(
14 | 'u',
15 | step=0.01,
16 | as_ = ['p', 'v']
17 | ).transform_calculate(
18 | uniform = 'quantileUniform(datum.p)',
19 | normal = 'quantileNormal(datum.p)'
20 | ).mark_point().encode(
21 | alt.Y('v:Q')
22 | )
23 |
24 | base.encode(x='uniform:Q') | base.encode(x='normal:Q')
25 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_tooltips.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Scatter Plot with Tooltips
3 | ---------------------------------
4 | A scatter plot of the cars dataset, with tooltips showing selected column
5 | values when you hover over points. We make the points larger so that it is
6 | easier to hover over them.
7 | """
8 | # category: simple charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.cars()
14 |
15 | alt.Chart(source).mark_circle(size=60).encode(
16 | x='Horsepower',
17 | y='Miles_per_Gallon',
18 | color='Origin',
19 | tooltip=['Name', 'Origin', 'Horsepower', 'Miles_per_Gallon']
20 | ).interactive()
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_with_labels.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Scatter Plot with Labels
3 | ===============================
4 | This example shows a basic scatter plot with labels created with Altair.
5 | """
6 | # category: scatter plots
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame({
11 | 'x': [1, 3, 5, 7, 9],
12 | 'y': [1, 3, 5, 7, 9],
13 | 'label': ['A', 'B', 'C', 'D', 'E']
14 | })
15 |
16 | points = alt.Chart(source).mark_point().encode(
17 | x='x:Q',
18 | y='y:Q'
19 | )
20 |
21 | text = points.mark_text(
22 | align='left',
23 | baseline='middle',
24 | dx=7
25 | ).encode(
26 | text='label'
27 | )
28 |
29 | points + text
30 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_with_loess.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Plot with LOESS Lines
3 | -----------------------------
4 | This example shows how to add a trend line to a scatter plot using
5 | the LOESS transform (LOcally Estimated Scatter Plot Smoothing).
6 | """
7 | # category: uncertainties and trends
8 |
9 | import altair as alt
10 | import pandas as pd
11 | import numpy as np
12 |
13 | np.random.seed(1)
14 |
15 | source = pd.DataFrame({
16 | 'x': np.arange(100),
17 | 'A': np.random.randn(100).cumsum(),
18 | 'B': np.random.randn(100).cumsum(),
19 | 'C': np.random.randn(100).cumsum(),
20 | })
21 |
22 | base = alt.Chart(source).mark_circle(opacity=0.5).transform_fold(
23 | fold=['A', 'B', 'C'],
24 | as_=['category', 'y']
25 | ).encode(
26 | alt.X('x:Q'),
27 | alt.Y('y:Q'),
28 | alt.Color('category:N')
29 | )
30 |
31 | base + base.transform_loess('x', 'y', groupby=['category']).mark_line(size=4)
32 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_with_rolling_mean.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Plot with Rolling Mean
3 | ------------------------------
4 | A scatter plot with a rolling mean overlay. In this example a 30 day window
5 | is used to calculate the mean of the maximum temperature around each date.
6 | """
7 | # category: scatter plots
8 |
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.seattle_weather()
13 |
14 | line = alt.Chart(source).mark_line(
15 | color='red',
16 | size=3
17 | ).transform_window(
18 | rolling_mean='mean(temp_max)',
19 | frame=[-15, 15]
20 | ).encode(
21 | x='date:T',
22 | y='rolling_mean:Q'
23 | )
24 |
25 | points = alt.Chart(source).mark_point().encode(
26 | x='date:T',
27 | y=alt.Y('temp_max:Q',
28 | axis=alt.Axis(title='Max Temp'))
29 | )
30 |
31 | points + line
32 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/scatter_with_shaded_area.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Plot with Shaded Area
3 | -----------------------------
4 | This example shows a scatter plot with shaded area,
5 | constructed using :ref:`area mark <user-guide-area-marks>` and :ref:`rect mark <user-guide-rect-marks>`.
6 | """
7 | # category: scatter plots
8 |
9 | import altair as alt
10 | import pandas as pd
11 | import numpy as np
12 |
13 | data = pd.DataFrame({
14 | "x": np.random.uniform(-4, 5, size=50),
15 | "y": np.random.uniform(2, 5, size=50),
16 | })
17 |
18 | rect_data = pd.DataFrame({
19 | "x1": [-2],
20 | "x2": [-1]
21 | })
22 |
23 | # define this interval between y = -x and y = -x
24 | df = pd.DataFrame({
25 | "x": range(7),
26 | "ymin": range(7),
27 | "ymax": range(1,8)
28 | })
29 |
30 | points = alt.Chart(data).mark_point().encode(
31 | x="x",
32 | y="y"
33 | )
34 |
35 | interval = alt.Chart(df).mark_area(opacity=0.3).encode(
36 | x="x:Q",
37 | y="ymin:Q",
38 | y2="ymax:Q"
39 | )
40 |
41 |
42 | rect = alt.Chart(rect_data).mark_rect(opacity=0.3).encode(
43 | x="x1",
44 | x2="x2",
45 | color=alt.ColorValue("#FF0000")
46 | )
47 |
48 | points + interval + rect
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/select_mark_area.py:
--------------------------------------------------------------------------------
1 | """
2 | Using Selection Interval with mark_area
3 | =========================================
4 |
5 | Because area is considered one object, just using the plain
6 | selector will select the entire area instead of just one part of it.
7 |
8 | This example shows how to use two areas, one on top of the other, and a
9 | `transform_filter` to fake out this effect.
10 |
11 | """
12 | # category: interactive charts
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.unemployment_across_industries.url
17 |
18 | base = alt.Chart(source).mark_area(
19 | color='goldenrod',
20 | opacity=0.3
21 | ).encode(
22 | x='yearmonth(date):T',
23 | y='sum(count):Q',
24 | )
25 |
26 | brush = alt.selection_interval(encodings=['x'])
27 | background = base.add_params(brush)
28 | selected = base.transform_filter(brush).mark_area(color='goldenrod')
29 |
30 | background + selected
31 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/selection_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Selection Histogram
3 | ===================
4 | This chart shows an example of using an interval selection to filter the
5 | contents of an attached histogram, allowing the user to see the proportion
6 | of items in each category within the selection.
7 | """
8 | # category: interactive charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.cars()
13 |
14 | brush = alt.selection_interval()
15 |
16 | points = alt.Chart(source).mark_point().encode(
17 | x='Horsepower:Q',
18 | y='Miles_per_Gallon:Q',
19 | color=alt.when(brush).then("Origin:N").otherwise(alt.value("lightgray"))
20 | ).add_params(
21 | brush
22 | )
23 |
24 | bars = alt.Chart(source).mark_bar().encode(
25 | y='Origin:N',
26 | color='Origin:N',
27 | x='count(Origin):Q'
28 | ).transform_filter(
29 | brush
30 | )
31 |
32 | points & bars
33 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/selection_layer_bar_month.py:
--------------------------------------------------------------------------------
1 | """
2 | Interactive Average
3 | ===================
4 | The plot below uses an interval selection, which causes the chart to include an interactive brush
5 | (shown in grey). The brush selection parameterizes the red guideline, which visualizes the average
6 | value within the selected interval.
7 | """
8 | # category: interactive charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.seattle_weather()
13 | brush = alt.selection_interval(encodings=['x'])
14 |
15 | bars = alt.Chart().mark_bar().encode(
16 | x='month(date):O',
17 | y='mean(precipitation):Q',
18 | opacity = alt.when(brush).then(alt.value(1)).otherwise(alt.value(0.7)),
19 | ).add_params(
20 | brush
21 | )
22 |
23 | line = alt.Chart().mark_rule(color='firebrick').encode(
24 | y='mean(precipitation):Q',
25 | size=alt.SizeValue(3)
26 | ).transform_filter(
27 | brush
28 | )
29 |
30 | alt.layer(bars, line, data=source)
31 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/selection_zorder.py:
--------------------------------------------------------------------------------
1 | """
2 | Selection zorder
3 | ================
4 | This example shows how to bring selected points to the front/foreground
5 | by using a condition to change the point's (z)order
6 | as it is hovered over with the pointer.
7 | This prevents that the selected points are obscured
8 | by those that are not selected.
9 | """
10 | # category: interactive charts
11 |
12 | import altair as alt
13 | from vega_datasets import data
14 |
15 |
16 | cars = data.cars.url
17 |
18 | hover = alt.selection_point(on='pointerover', nearest=True, empty=False)
19 | when_hover = alt.when(hover)
20 |
21 | chart = alt.Chart(cars, title='Selection obscured by other points').mark_circle(opacity=1).encode(
22 | x='Horsepower:Q',
23 | y='Miles_per_Gallon:Q',
24 | color=when_hover.then(alt.value("coral")).otherwise(alt.value("lightgray")),
25 | size=when_hover.then(alt.value(300)).otherwise(alt.value(30))
26 | ).add_params(
27 | hover
28 | )
29 |
30 | chart | chart.encode(
31 | order=when_hover.then(alt.value(1)).otherwise(alt.value(0))
32 | ).properties(
33 | title='Selection brought to front'
34 | )
35 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Bar Chart
3 | ================
4 | This example shows a basic bar chart created with Altair.
5 | """
6 | # category: simple charts
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame({
11 | 'a': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'],
12 | 'b': [28, 55, 43, 91, 81, 53, 19, 87, 52]
13 | })
14 |
15 | alt.Chart(source).mark_bar().encode(
16 | x='a',
17 | y='b'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_heatmap.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Heatmap
3 | --------------
4 | This example shows a simple heatmap for showing gridded data.
5 | """
6 | # category: simple charts
7 | import altair as alt
8 | import numpy as np
9 | import pandas as pd
10 |
11 | # Compute x^2 + y^2 across a 2D grid
12 | x, y = np.meshgrid(range(-5, 5), range(-5, 5))
13 | z = x ** 2 + y ** 2
14 |
15 | # Convert this grid to columnar data expected by Altair
16 | source = pd.DataFrame({'x': x.ravel(),
17 | 'y': y.ravel(),
18 | 'z': z.ravel()})
19 |
20 | alt.Chart(source).mark_rect().encode(
21 | x='x:O',
22 | y='y:O',
23 | color='z:Q'
24 | )
25 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Histogram
3 | ----------------
4 | This example shows how to make a basic histogram, based on the vega-lite docs
5 | https://vega.github.io/vega-lite/examples/histogram.html
6 | """
7 | # category: simple charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.movies.url
12 |
13 | alt.Chart(source).mark_bar().encode(
14 | alt.X("IMDB_Rating:Q", bin=True),
15 | y='count()',
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_line_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Line Chart
3 | -----------------
4 | This chart shows the most basic line chart, made from a dataframe with two
5 | columns.
6 | """
7 | # category: simple charts
8 |
9 | import altair as alt
10 | import numpy as np
11 | import pandas as pd
12 |
13 | x = np.arange(100)
14 | source = pd.DataFrame({
15 | 'x': x,
16 | 'f(x)': np.sin(x / 5)
17 | })
18 |
19 | alt.Chart(source).mark_line().encode(
20 | x='x',
21 | y='f(x)'
22 | )
23 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_scatter_with_errorbars.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Scatter Plot with Errorbars
3 | ----------------------------------
4 | A simple scatter plot of a data set with errorbars.
5 | """
6 | # category: uncertainties and trends
7 | import altair as alt
8 | import pandas as pd
9 | import numpy as np
10 |
11 | # generate some data points with uncertainties
12 | np.random.seed(0)
13 | x = [1, 2, 3, 4, 5]
14 | y = np.random.normal(10, 0.5, size=len(x))
15 | yerr = 0.2
16 |
17 | # set up data frame
18 | source = pd.DataFrame({"x": x, "y": y, "yerr": yerr})
19 |
20 | # the base chart
21 | base = alt.Chart(source).transform_calculate(
22 | ymin="datum.y-datum.yerr",
23 | ymax="datum.y+datum.yerr"
24 | )
25 |
26 | # generate the points
27 | points = base.mark_point(
28 | filled=True,
29 | size=50,
30 | color='black'
31 | ).encode(
32 | x=alt.X('x', scale=alt.Scale(domain=(0, 6))),
33 | y=alt.Y('y', scale=alt.Scale(zero=False))
34 | )
35 |
36 | # generate the error bars
37 | errorbars = base.mark_errorbar().encode(
38 | x="x",
39 | y="ymin:Q",
40 | y2="ymax:Q"
41 | )
42 |
43 | points + errorbars
44 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/simple_stacked_area_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Stacked Area Chart
3 | -------------------------
4 | This example shows how to make a simple stacked area chart.
5 | """
6 | # category: simple charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_area().encode(
13 | x="year:T",
14 | y="net_generation:Q",
15 | color="source:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/slider_cutoff.py:
--------------------------------------------------------------------------------
1 | """
2 | Slider Cutoff
3 | =============
4 | This example shows how to bind a variable parameter to a slider, and how to use the corresponding bound value to color data points. This example is based on an example from the Altair 4 documentation for Interactions, in which the interactivity was accomplished using a selection. The version below has been simplified significantly through the use of a variable parameter. Variable parameters were added in Altair 5.
5 | """
6 | # category: interactive charts
7 | import altair as alt
8 | import pandas as pd
9 | import numpy as np
10 |
11 | rand = np.random.RandomState(42)
12 |
13 | df = pd.DataFrame({
14 | 'xval': range(100),
15 | 'yval': rand.randn(100).cumsum()
16 | })
17 |
18 | slider = alt.binding_range(min=0, max=100, step=1)
19 | cutoff = alt.param(bind=slider, value=50)
20 | predicate = alt.datum.xval < cutoff
21 |
22 | alt.Chart(df).mark_point().encode(
23 | x='xval',
24 | y='yval',
25 | color=alt.when(predicate).then(alt.value("red")).otherwise(alt.value("blue")),
26 | ).add_params(
27 | cutoff
28 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/slope_graph.py:
--------------------------------------------------------------------------------
1 | """
2 | Slope Graph
3 | -----------------------
4 | This example shows how to make Slope Graph.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_line().encode(
13 | x='year:O',
14 | y='median(yield)',
15 | color='site'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/sorted_error_bars_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Sorted Error Bars showing Confidence Interval
3 | =============================================
4 | This example shows how to show error bars using confidence intervals, while also sorting the y-axis based on x-axis values.
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.barley()
12 |
13 | points = alt.Chart(source).mark_point(
14 | filled=True,
15 | color='black'
16 | ).encode(
17 | x=alt.X('mean(yield)', title='Barley Yield'),
18 | y=alt.Y(
19 | 'variety',
20 | sort=alt.EncodingSortField(
21 | field='yield',
22 | op='mean',
23 | order='descending'
24 | )
25 | )
26 | ).properties(
27 | width=400,
28 | height=250
29 | )
30 |
31 | error_bars = points.mark_rule().encode(
32 | x='ci0(yield)',
33 | x2='ci1(yield)',
34 | )
35 |
36 | points + error_bars
37 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/stacked_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Bar Chart
3 | -----------------
4 |
5 | This is an example of a stacked bar chart using data which contains crop yields over different regions and different years in the 1930s.
6 | """
7 | # category: bar charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.barley()
12 |
13 | alt.Chart(source).mark_bar().encode(
14 | x='variety',
15 | y='sum(yield)',
16 | color='site'
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/stacked_bar_chart_sorted_segments.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Bar Chart with Sorted Segments
3 | --------------------------------------
4 | This is an example of a stacked-bar chart with the segments of each bar resorted.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield)',
14 | y='variety',
15 | color='site',
16 | order=alt.Order(
17 | # Sort the segments of the bars by this field
18 | 'site',
19 | sort='ascending'
20 | )
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/stacked_bar_chart_with_text.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Bar Chart with Text Overlay
3 | ===================================
4 | This example shows how to overlay text on a stacked bar chart. For both the
5 | bar and text marks, we use the ``stack`` argument in the ``x`` encoding to
6 | cause the values to be stacked horizontally.
7 | """
8 | # category: bar charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source=data.barley()
13 |
14 | bars = alt.Chart(source).mark_bar().encode(
15 | x=alt.X('sum(yield):Q', stack='zero'),
16 | y=alt.Y('variety:N'),
17 | color=alt.Color('site')
18 | )
19 |
20 | text = alt.Chart(source).mark_text(dx=-15, dy=3, color='white').encode(
21 | x=alt.X('sum(yield):Q', stack='zero'),
22 | y=alt.Y('variety:N'),
23 | detail='site:N',
24 | text=alt.Text('sum(yield):Q', format='.1f')
25 | )
26 |
27 | bars + text
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/stem_and_leaf.py:
--------------------------------------------------------------------------------
1 | """
2 | Stem and Leaf Plot
3 | ------------------
4 | This example shows how to make a stem and leaf plot.
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | import pandas as pd
9 | import numpy as np
10 | np.random.seed(42)
11 |
12 | # Generating random data
13 | source = pd.DataFrame({'samples': np.random.normal(50, 15, 100).astype(int).astype(str)})
14 |
15 | # Splitting stem and leaf
16 | source['stem'] = source['samples'].str[:-1]
17 | source['leaf'] = source['samples'].str[-1]
18 |
19 | source = source.sort_values(by=['stem', 'leaf'])
20 |
21 | # Determining leaf position
22 | source['position'] = source.groupby('stem').cumcount().add(1)
23 |
24 | # Creating stem and leaf plot
25 | alt.Chart(source).mark_text(
26 | align='left',
27 | baseline='middle',
28 | dx=-5
29 | ).encode(
30 | alt.X('position:Q', title='',
31 | axis=alt.Axis(ticks=False, labels=False, grid=False)
32 | ),
33 | alt.Y('stem:N', title='', axis=alt.Axis(tickSize=0)),
34 | text='leaf:N',
35 | ).configure_axis(
36 | labelFontSize=20
37 | ).configure_text(
38 | fontSize=20
39 | )
40 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/step_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Step Chart
3 | ----------
4 | This example shows Google's stock price over time.
5 | This uses the "step-after" interpolation scheme.
6 | The full list of interpolation options includes 'linear',
7 | 'linear-closed', 'step', 'step-before', 'step-after', 'basis',
8 | 'basis-open', 'basis-closed', 'cardinal', 'cardinal-open',
9 | 'cardinal-closed', 'bundle', and 'monotone'.
10 | """
11 | # category: line charts
12 | import altair as alt
13 | from vega_datasets import data
14 |
15 | source = data.stocks()
16 |
17 | alt.Chart(source).mark_line(interpolate='step-after').encode(
18 | x='date',
19 | y='price'
20 | ).transform_filter(
21 | alt.datum.symbol == 'GOOG'
22 | )
23 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/streamgraph.py:
--------------------------------------------------------------------------------
1 | """
2 | Streamgraph
3 | -----------------
4 | This example shows the streamgraph from vega-lite examples.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.unemployment_across_industries.url
11 |
12 | alt.Chart(source).mark_area().encode(
13 | alt.X('yearmonth(date):T',
14 | axis=alt.Axis(format='%Y', domain=False, tickSize=0)
15 | ),
16 | alt.Y('sum(count):Q', stack='center', axis=None),
17 | alt.Color('series:N',
18 | scale=alt.Scale(scheme='category20b')
19 | )
20 | ).interactive()
21 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/strip_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Strip Plot
3 | -----------------
4 | A simple example of how to make a strip plot.
5 | """
6 | # category: simple charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | alt.Chart(source).mark_tick().encode(
13 | x='Horsepower:Q',
14 | y='Cylinders:O'
15 | )
16 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/table_bubble_plot_github.py:
--------------------------------------------------------------------------------
1 | """
2 | Table Bubble Plot (Github Punch Card)
3 | -------------------------------------
4 | This example shows github contributions by the day of week and hour of the day.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.github.url
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | x='hours(time):O',
14 | y='day(time):O',
15 | size='sum(count):Q'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/top_k_items.py:
--------------------------------------------------------------------------------
1 | """
2 | Top K Items
3 | -----------
4 | This example shows how to use the window and transformation filter to display
5 | the Top items of a long list of items in decreasing order.
6 | Here we sort the top 10 highest ranking movies of IMDB.
7 | """
8 | # category: advanced calculations
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.movies.url
13 |
14 | # Top 10 movies by IMBD rating
15 | alt.Chart(
16 | source,
17 | ).mark_bar().encode(
18 | x=alt.X('Title:N', sort='-y'),
19 | y=alt.Y('IMDB_Rating:Q'),
20 | color=alt.Color('IMDB_Rating:Q')
21 |
22 | ).transform_window(
23 | rank='rank(IMDB_Rating)',
24 | sort=[alt.SortField('IMDB_Rating', order='descending')]
25 | ).transform_filter(
26 | (alt.datum.rank < 10)
27 | )
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/top_k_with_others.py:
--------------------------------------------------------------------------------
1 | """
2 | Top-K Plot with Others
3 | ----------------------
4 | This example shows how to use aggregate, window, and calculate transformations
5 | to display the top-k directors by average worldwide gross while grouping the
6 | remaining directors as 'All Others'.
7 | """
8 | # category: advanced calculations
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.movies.url
13 |
14 | alt.Chart(source).mark_bar().encode(
15 | x=alt.X("aggregate_gross:Q", aggregate="mean", title=None),
16 | y=alt.Y(
17 | "ranked_director:N",
18 | sort=alt.Sort(op="mean", field="aggregate_gross", order="descending"),
19 | title=None,
20 | ),
21 | ).transform_aggregate(
22 | aggregate_gross='mean(Worldwide_Gross)',
23 | groupby=["Director"],
24 | ).transform_window(
25 | rank='row_number()',
26 | sort=[alt.SortField("aggregate_gross", order="descending")],
27 | ).transform_calculate(
28 | ranked_director="datum.rank < 10 ? datum.Director : 'All Others'"
29 | ).properties(
30 | title="Top Directors by Average Worldwide Gross",
31 | )
32 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/trail_marker.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Varying Size
3 | ----------------------------
4 | This is example of using the ``trail`` marker to vary the size of a line.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | alt.Chart(source).mark_trail().encode(
13 | x='year:T',
14 | y='wheat:Q',
15 | size='wheat:Q'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/us_incomebrackets_by_state_facet.py:
--------------------------------------------------------------------------------
1 | """
2 | US Income by State: Wrapped Facet
3 | ---------------------------------
4 | This example shows how to create a map of income in the US by state,
5 | faceted over income brackets
6 | """
7 | # category: maps
8 |
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | states = alt.topo_feature(data.us_10m.url, 'states')
13 | source = data.income.url
14 |
15 | alt.Chart(source).mark_geoshape().encode(
16 | shape='geo:G',
17 | color='pct:Q',
18 | tooltip=['name:N', 'pct:Q'],
19 | facet=alt.Facet('group:N', columns=2),
20 | ).transform_lookup(
21 | lookup='id',
22 | from_=alt.LookupData(data=states, key='id'),
23 | as_='geo'
24 | ).properties(
25 | width=300,
26 | height=175,
27 | ).project(
28 | type='albersUsa'
29 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/us_population_over_time_facet.py:
--------------------------------------------------------------------------------
1 | """
2 | US Population: Wrapped Facet
3 | ============================
4 | This chart visualizes the age distribution of the US population over time,
5 | using a wrapped faceting of the data by decade.
6 | """
7 | # category: case studies
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.population.url
12 |
13 | alt.Chart(source).mark_area().encode(
14 | x='age:O',
15 | y=alt.Y(
16 | 'sum(people):Q',
17 | title='Population',
18 | axis=alt.Axis(format='~s')
19 | ),
20 | facet=alt.Facet('year:O', columns=5),
21 | ).properties(
22 | title='US Age Distribution By Year',
23 | width=90,
24 | height=80
25 | )
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/violin_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Violin Plot
3 | -----------
4 | This example shows how to make a Violin Plot using Altair's density transform.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | alt.Chart(data.cars()).transform_density(
11 | 'Miles_per_Gallon',
12 | as_=['Miles_per_Gallon', 'density'],
13 | extent=[5, 50],
14 | groupby=['Origin']
15 | ).mark_area(orient='horizontal').encode(
16 | y='Miles_per_Gallon:Q',
17 | color='Origin:N',
18 | x=alt.X(
19 | 'density:Q',
20 | stack='center',
21 | impute=None,
22 | title=None,
23 | axis=alt.Axis(labels=False, values=[0],grid=False, ticks=True),
24 | ),
25 | column=alt.Column(
26 | 'Origin:N',
27 | header=alt.Header(
28 | titleOrient='bottom',
29 | labelOrient='bottom',
30 | labelPadding=0,
31 | ),
32 | )
33 | ).properties(
34 | width=100
35 | ).configure_facet(
36 | spacing=0
37 | ).configure_view(
38 | stroke=None
39 | )
40 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/wilkinson-dot-plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Wilkinson Dot Plot
3 | ------------------
4 | An example of a `Wilkinson Dot Plot <https://en.wikipedia.org/wiki/Dot_plot_(statistics)>`_
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame(
12 | {"data":[1,1,1,1,1,1,1,1,1,1,
13 | 2,2,2,
14 | 3,3,
15 | 4,4,4,4,4,4]
16 | }
17 | )
18 |
19 | alt.Chart(source).mark_circle(opacity=1).transform_window(
20 | id='rank()',
21 | groupby=['data']
22 | ).encode(
23 | alt.X('data:O'),
24 | alt.Y('id:O',
25 | axis=None,
26 | sort='descending')
27 | ).properties(height=100)
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/world_map.py:
--------------------------------------------------------------------------------
1 | """
2 | World Map
3 | ---------
4 |
5 | This example shows how to create a world map using data generators for
6 | different background layers.
7 | """
8 | # category: maps
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | # Data generators for the background
14 | sphere = alt.sphere()
15 | graticule = alt.graticule()
16 |
17 | # Source of land data
18 | source = alt.topo_feature(data.world_110m.url, 'countries')
19 |
20 | # Layering and configuring the components
21 | alt.layer(
22 | alt.Chart(sphere).mark_geoshape(fill='lightblue'),
23 | alt.Chart(graticule).mark_geoshape(stroke='white', strokeWidth=0.5),
24 | alt.Chart(source).mark_geoshape(fill='ForestGreen', stroke='black')
25 | ).project(
26 | 'naturalEarth1'
27 | ).properties(width=600, height=400).configure_view(stroke=None)
28 |
--------------------------------------------------------------------------------
/tests/examples_arguments_syntax/world_projections.py:
--------------------------------------------------------------------------------
1 | """
2 | World Projections
3 | -----------------
4 | This example shows a map of the countries of the world.
5 | Use the dropdown menu to compare projections. For more details on the `project` arguments, see the API of `altair.Projection <https://altair-viz.github.io/user_guide/generated/core/altair.Projection.html>`_.
6 | """
7 | # category: maps
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = alt.topo_feature(data.world_110m.url, 'countries')
12 |
13 | input_dropdown = alt.binding_select(options=[
14 | "albers",
15 | "albersUsa",
16 | "azimuthalEqualArea",
17 | "azimuthalEquidistant",
18 | "conicEqualArea",
19 | "conicEquidistant",
20 | "equalEarth",
21 | "equirectangular",
22 | "gnomonic",
23 | "mercator",
24 | "naturalEarth1",
25 | "orthographic",
26 | "stereographic",
27 | "transverseMercator"
28 | ], name='Projection ')
29 | param_projection = alt.param(value="equalEarth", bind=input_dropdown)
30 |
31 | alt.Chart(source, width=500, height=300).mark_geoshape(
32 | fill='lightgray',
33 | stroke='gray'
34 | ).project(
35 | type=alt.expr(param_projection.name)
36 | ).add_params(param_projection)
37 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/__init__.py:
--------------------------------------------------------------------------------
1 | import os
2 | from typing import Set
3 |
4 | # Set of the names of examples that should have SVG static images.
5 | # This is for examples that VlConvert's PNG export does not support.
6 | SVG_EXAMPLES: Set[str] = {"isotype_emoji"}
7 |
8 |
9 | def iter_examples_methods_syntax():
10 | """Iterate over the examples in this directory.
11 |
12 | Each item is a dict with the following keys:
13 | - "name" : the unique name of the example
14 | - "filename" : the full file path to the example
15 | """
16 | examples_methods_syntax_dir = os.path.abspath(os.path.dirname(__file__))
17 | for filename in os.listdir(examples_methods_syntax_dir):
18 | name, ext = os.path.splitext(filename)
19 | if name.startswith("_") or ext != ".py":
20 | continue
21 | yield {
22 | "name": name,
23 | "filename": os.path.join(examples_methods_syntax_dir, filename),
24 | "use_svg": name in SVG_EXAMPLES,
25 | }
26 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/annual_weather_heatmap.py:
--------------------------------------------------------------------------------
1 | """
2 | Annual Weather Heatmap
3 | ----------------------
4 | """
5 | # category: tables
6 | import altair as alt
7 | from vega_datasets import data
8 |
9 | source = data.seattle_weather()
10 |
11 | alt.Chart(source, title="Daily Max Temperatures (C) in Seattle, WA").mark_rect().encode(
12 | alt.X("date(date):O").title("Day").axis(format="%e", labelAngle=0),
13 | alt.Y("month(date):O").title("Month"),
14 | alt.Color("max(temp_max)").title(None),
15 | tooltip=[
16 | alt.Tooltip("monthdate(date)", title="Date"),
17 | alt.Tooltip("max(temp_max)", title="Max Temp"),
18 | ],
19 | ).configure_view(
20 | step=13,
21 | strokeWidth=0
22 | ).configure_axis(
23 | domain=False
24 | )
25 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/anscombe_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Anscombe's Quartet
3 | ------------------
4 |
5 | `Anscombe's Quartet <https://en.wikipedia.org/wiki/Anscombe%27s_quartet>`_
6 | is a famous dataset constructed by Francis Anscombe.
7 | It is made of 4 different subsets of data.
8 | Each subset has very different characteristics, even though common summary
9 | statistics such as mean and variance are identical.
10 |
11 | This example shows how to make a faceted plot, with each facet
12 | showing a different subset of the data.
13 | """
14 | # category: case studies
15 | import altair as alt
16 | from vega_datasets import data
17 |
18 | source = data.anscombe()
19 |
20 | alt.Chart(source).mark_circle().encode(
21 | alt.X("X").scale(zero=False),
22 | alt.Y("Y").scale(zero=False),
23 | alt.Facet("Series", columns=2),
24 | ).properties(
25 | width=180,
26 | height=180,
27 | )
28 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/area_faceted.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Area Chart
3 | ------------------
4 | Multiple area subcharts, one for each company.
5 | We also show filtering out one of the companies,
6 | and sorting the companies in a custom order.
7 | """
8 | # category: area charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.stocks()
13 |
14 | alt.Chart(source).transform_filter(alt.datum.symbol != "GOOG").mark_area().encode(
15 | x="date:T",
16 | y="price:Q",
17 | color="symbol:N",
18 | row=alt.Row("symbol:N").sort(["MSFT", "AAPL", "IBM", "AMZN"]),
19 | ).properties(height=50, width=400)
20 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/bar_chart_sorted.py:
--------------------------------------------------------------------------------
1 | """
2 | Sorted Bar Chart
3 | ================
4 | This example shows a bar chart sorted by a calculated value.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield):Q',
14 | y=alt.Y('site:N').sort('-x')
15 | )
16 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/bar_chart_with_labels_measured_luminance.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Labels based on Measured Luminance
3 | =================================================
4 | This example shows a basic horizontal bar chart with labels where the measured luminance to decides if the text overlay is be colored ``black`` or ``white``.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | base = alt.Chart(source).encode(
13 | x=alt.X('sum(yield):Q').stack('zero'),
14 | y=alt.Y('site:O').sort('-x'),
15 | text=alt.Text('sum(yield):Q', format='.0f')
16 | )
17 |
18 | bars = base.mark_bar(
19 | tooltip=alt.expr("luminance(scale('color', datum.sum_yield))")
20 | ).encode(
21 | color='sum(yield):Q'
22 | )
23 |
24 | text = base.mark_text(
25 | align='right',
26 | dx=-3,
27 | color=alt.expr("luminance(scale('color', datum.sum_yield)) > 0.5 ? 'black' : 'white'")
28 | )
29 |
30 | bars + text
31 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/bar_chart_with_range.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart with Range
3 | ====================
4 | This example shows a range bar chart where each bar displays information of a low and high value.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.seattle_weather()
11 |
12 | bar = alt.Chart(source).mark_bar(cornerRadius=10, height=10).encode(
13 | x=alt.X('min(temp_min):Q').scale(domain=[-15, 45]).title('Temperature (°C)'),
14 | x2='max(temp_max):Q',
15 | y=alt.Y('month(date):O').title(None)
16 | )
17 |
18 | text_min = alt.Chart(source).mark_text(align='right', dx=-5).encode(
19 | x='min(temp_min):Q',
20 | y=alt.Y('month(date):O'),
21 | text='min(temp_min):Q'
22 | )
23 |
24 | text_max = alt.Chart(source).mark_text(align='left', dx=5).encode(
25 | x='max(temp_max):Q',
26 | y=alt.Y('month(date):O'),
27 | text='max(temp_max):Q'
28 | )
29 |
30 | (bar + text_min + text_max).properties(
31 | title=alt.Title(text='Temperature variation by month', subtitle='Seatle weather, 2012-2015')
32 | )
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/bar_chart_with_single_threshold.py:
--------------------------------------------------------------------------------
1 | """
2 | Bar Chart Highlighting Values beyond a Threshold
3 | ------------------------------------------------
4 | This example shows a bar chart highlighting values beyond a threshold.
5 | """
6 | # category: bar charts
7 | import pandas as pd
8 | import altair as alt
9 |
10 | source = pd.DataFrame({
11 | "Day": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
12 | "Value": [55, 112, 65, 38, 80, 138, 120, 103, 395, 200, 72, 51, 112, 175, 131]
13 | })
14 | threshold = 300
15 |
16 | bars = alt.Chart(source).mark_bar(color="steelblue").encode(
17 | x="Day:O",
18 | y="Value:Q",
19 | )
20 |
21 | highlight = bars.mark_bar(color="#e45755").encode(
22 | y2=alt.Y2(datum=threshold)
23 | ).transform_filter(
24 | alt.datum.Value > threshold
25 | )
26 |
27 | rule = alt.Chart().mark_rule().encode(
28 | y=alt.Y(datum=threshold)
29 | )
30 |
31 | label = rule.mark_text(
32 | x="width",
33 | dx=-2,
34 | align="right",
35 | baseline="bottom",
36 | text="hazardous"
37 | )
38 |
39 | (bars + highlight + rule + label)
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/beckers_barley_wrapped_facet.py:
--------------------------------------------------------------------------------
1 | """
2 | Becker's Barley Wrapped Facet Plot
3 | ----------------------------------
4 | The example demonstrates the faceted charts created by Richard Becker,
5 | William Cleveland and others in the 1990s. Using the visualization technique
6 | where each row is a different site (i.e. the chart is faceted by site),
7 | they identified an anomaly in a widely used agriculatural dataset,
8 | where the "Morris" site accidentally had the years 1931 and 1932 swapped.
9 | They named this
10 | `"The Morris Mistake." <http://ml.stat.purdue.edu/stat695t/writings/Trellis.User.pdf>`_.
11 | """
12 | # category: case studies
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.barley.url
17 |
18 | alt.Chart(source).mark_point().encode(
19 | alt.X("median(yield):Q").scale(zero=False),
20 | y="variety:O",
21 | color="year:N",
22 | facet=alt.Facet("site:O", columns=2),
23 | ).properties(
24 | width=200,
25 | height=100,
26 | )
27 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/bump_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Bump Chart
3 | ----------
4 | This example shows a bump chart. The data is first grouped into six-month
5 | intervals using pandas. The ranks are computed by Altair using a
6 | window transform.
7 | """
8 | # category: line charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 | import pandas as pd
13 |
14 | stocks = data.stocks()
15 | source = stocks.groupby([pd.Grouper(key="date", freq="6MS"),"symbol"]).mean().reset_index()
16 |
17 | alt.Chart(source).mark_line(point=True).encode(
18 | x=alt.X("date:O").timeUnit("yearmonth").title("date"),
19 | y="rank:O",
20 | color=alt.Color("symbol:N")
21 | ).transform_window(
22 | rank="rank()",
23 | sort=[alt.SortField("price", order="descending")],
24 | groupby=["date"]
25 | ).properties(
26 | title="Bump Chart for Stock Prices",
27 | width=600,
28 | height=150,
29 | )
30 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/cumulative_count_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Cumulative Count Chart
3 | ----------------------
4 | This example shows an area chart with cumulative count.
5 | Adapted from https://vega.github.io/vega-lite/examples/area_cumulative_freq.html
6 |
7 | """
8 | # category: distributions
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.movies.url
14 |
15 | alt.Chart(source).transform_window(
16 | cumulative_count="count()",
17 | sort=[{"field": "IMDB_Rating"}],
18 | ).mark_area().encode(
19 | x="IMDB_Rating:Q",
20 | y=alt.Y("cumulative_count:Q").stack(False)
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/density_stack.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Density Estimates
3 | -------------------------
4 | To plot a stacked graph of estimates, use a shared ``extent`` and a fixed
5 | number of subdivision ``steps`` to ensure that the points for each area align
6 | well. Density estimates of measurements for each iris flower feature are plot
7 | in a stacked method. In addition, setting ``counts`` to true multiplies the
8 | densities by the number of data points in each group, preserving proportional
9 | differences.
10 | """
11 | # category: distributions
12 |
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.iris()
17 |
18 | alt.Chart(source).transform_fold(
19 | ['petalWidth',
20 | 'petalLength',
21 | 'sepalWidth',
22 | 'sepalLength'],
23 | as_ = ['Measurement_type', 'value']
24 | ).transform_density(
25 | density='value',
26 | bandwidth=0.3,
27 | groupby=['Measurement_type'],
28 | extent= [0, 8],
29 | counts = True,
30 | steps=200
31 | ).mark_area().encode(
32 | alt.X('value:Q'),
33 | alt.Y('density:Q').stack('zero'),
34 | alt.Color('Measurement_type:N')
35 | ).properties(width=400, height=100)
36 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/distributions_faceted_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Faceted Histogram
3 | -----------------
4 | This example shows how to make a basic faceted histogram,
5 | with one histogram subplot for different subsets of the data.
6 |
7 | Based off the vega-lite example:
8 | https://vega.github.io/vega-lite/examples/trellis_bar_histogram.html
9 | """
10 | # category: distributions
11 | import altair as alt
12 | from vega_datasets import data
13 |
14 | source = data.cars()
15 |
16 | alt.Chart(source).mark_bar().encode(
17 | alt.X("Horsepower:Q").bin(),
18 | y="count()",
19 | row="Origin",
20 | )
21 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/donut_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Donut Chart
3 | -----------
4 | This example shows how to make a Donut Chart using ``mark_arc``.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Donut Chart <https://vega.github.io/vega-lite/examples/arc_donut.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({
14 | "category": [1, 2, 3, 4, 5, 6],
15 | "value": [4, 6, 10, 3, 7, 8]
16 | })
17 |
18 | alt.Chart(source).mark_arc(innerRadius=50).encode(
19 | theta="value",
20 | color="category:N",
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/errorbars_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Error Bars with Confidence Interval
3 | ======================================
4 | This example shows how to show error bars using confidence intervals.
5 | The confidence intervals are computed internally in vega by a non-parametric
6 | `bootstrap of the mean <https://github.com/vega/vega-statistics/blob/master/src/bootstrapCI.js>`_.
7 | """
8 | # category: uncertainties and trends
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.barley()
13 |
14 | error_bars = alt.Chart(source).mark_errorbar(extent='ci').encode(
15 | alt.X('yield').scale(zero=False),
16 | alt.Y('variety')
17 | )
18 |
19 | points = alt.Chart(source).mark_point(filled=True, color='black').encode(
20 | x=alt.X('mean(yield)'),
21 | y=alt.Y('variety'),
22 | )
23 |
24 | error_bars + points
25 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/errorbars_with_std.py:
--------------------------------------------------------------------------------
1 | """
2 | Error Bars with Standard Deviation
3 | ----------------------------------
4 | This example shows how to show error bars with standard deviation using crop yields data of different
5 | in the years of 1930s.
6 | """
7 | # category: uncertainties and trends
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.barley()
12 |
13 | error_bars = alt.Chart(source).mark_errorbar(extent='stdev').encode(
14 | x=alt.X('yield').scale(zero=False),
15 | y=alt.Y('variety')
16 | )
17 |
18 | points = alt.Chart(source).mark_point(filled=True, color='black').encode(
19 | x=alt.X('mean(yield)'),
20 | y=alt.Y('variety'),
21 | )
22 |
23 | error_bars + points
24 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/gapminder_bubble_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Gapminder Bubble Plot
3 | =====================
4 | This example shows how to make a bubble plot showing the correlation between
5 | health and income for 187 countries in the world (modified from an example
6 | in Lisa Charlotte Rost's blog post `'One Chart, Twelve Charting Libraries' <http://lisacharlotterost.github.io/2016/05/17/one-chart-code/>`_.
7 | """
8 | # category: case studies
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.gapminder_health_income.url
13 |
14 | alt.Chart(source).mark_circle().encode(
15 | alt.X('income:Q').scale(type='log'),
16 | alt.Y('health:Q').scale(zero=False),
17 | size='population:Q'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/groupby-map.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Points with Proportional Symbols Map
3 | ============================================
4 | This is a layered geographic visualization that groups points by state.
5 | """
6 | # category: maps
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | airports = data.airports.url
11 | states = alt.topo_feature(data.us_10m.url, feature='states')
12 |
13 | # US states background
14 | background = alt.Chart(states).mark_geoshape(
15 | fill='lightgray',
16 | stroke='white'
17 | ).properties(
18 | width=500,
19 | height=300
20 | ).project('albersUsa')
21 |
22 | # Airports grouped by state
23 | points = alt.Chart(airports, title='Number of airports in US').transform_aggregate(
24 | latitude='mean(latitude)',
25 | longitude='mean(longitude)',
26 | count='count()',
27 | groupby=['state']
28 | ).mark_circle().encode(
29 | longitude='longitude:Q',
30 | latitude='latitude:Q',
31 | size=alt.Size('count:Q').title('Number of Airports'),
32 | color=alt.value('steelblue'),
33 | tooltip=['state:N','count:Q']
34 | )
35 |
36 | background + points
37 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/grouped_bar_chart2.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with xOffset
3 | ------------------------------
4 | Like :ref:`gallery_grouped_bar_chart`, this example shows a grouped bar chart. Whereas :ref:`gallery_grouped_bar_chart` used the ``column`` encoding channel, this example uses the ``xOffset`` encoding channel. This is adapted from a corresponding Vega-Lite Example:
5 | `Grouped Bar Chart <https://vega.github.io/vega-lite/examples/bar_grouped.html>`_.
6 | """
7 | # category: bar charts
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame({
12 | "Category":list("AAABBBCCC"),
13 | "Group":list("xyzxyzxyz"),
14 | "Value":[0.1, 0.6, 0.9, 0.7, 0.2, 1.1, 0.6, 0.1, 0.2]
15 | })
16 |
17 | alt.Chart(source).mark_bar().encode(
18 | x="Category:N",
19 | y="Value:Q",
20 | xOffset="Group:N",
21 | color="Group:N"
22 | )
23 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/grouped_bar_chart_overlapping_bars.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with xOffset and overlapping bars
3 | ---------------------------------------------------
4 | Like :ref:`gallery_grouped_bar_chart2`, this example shows a grouped bar chart using the ``xOffset`` encoding channel, but in this example the bars are partly overlapping within each group.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | import pandas as pd
9 |
10 | source = pd.DataFrame(
11 | {
12 | "category": list("AABBCC"),
13 | "group": list("xyxyxy"),
14 | "value": [0.1, 0.6, 0.7, 0.2, 0.6, 0.1],
15 | }
16 | )
17 |
18 | base = alt.Chart(source, width=alt.Step(12)).encode(
19 | x="category:N",
20 | y="value:Q",
21 | xOffset=alt.XOffset("group:N").scale(paddingOuter=0.5),
22 | )
23 |
24 | alt.layer(
25 | base.mark_bar(size=20, stroke="white", fillOpacity=0.9).encode(fill="group:N"),
26 | base.mark_text(dy=-5).encode(text="value:Q"),
27 | )
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/grouped_bar_chart_with_error_bars.py:
--------------------------------------------------------------------------------
1 | """
2 | Grouped Bar Chart with Error Bars
3 | ---------------------------------
4 | This example shows a grouped bar chart with error bars.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | bars = alt.Chart().mark_bar().encode(
13 | x='year:O',
14 | y=alt.Y('mean(yield):Q').title('Mean Yield'),
15 | color='year:N',
16 | )
17 |
18 | error_bars = alt.Chart().mark_errorbar(extent='ci').encode(
19 | x='year:O',
20 | y='yield:Q'
21 | )
22 |
23 | alt.layer(bars, error_bars, data=source).facet(
24 | column='site:N'
25 | )
26 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/histogram_gradient_color.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with Gradient Color
3 | -----------------------------
4 | This example shows how to make a histogram with gradient color.
5 | The low-high IMDB rating is represented with the color scheme `pinkyellowgreen`.
6 | """
7 | # category: distributions
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.movies.url
12 |
13 | alt.Chart(source).mark_bar().encode(
14 | alt.X("IMDB_Rating:Q").bin(maxbins=20).scale(domain=[1, 10]),
15 | alt.Y('count()'),
16 | alt.Color("IMDB_Rating:Q").bin(maxbins=20).scale(scheme='pinkyellowgreen')
17 | )
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/histogram_heatmap.py:
--------------------------------------------------------------------------------
1 | """
2 | 2D Histogram Heatmap
3 | --------------------
4 | This example shows how to make a heatmap from binned quantitative data.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | alt.Chart(source).mark_rect().encode(
13 | alt.X('IMDB_Rating:Q').bin(maxbins=60),
14 | alt.Y('Rotten_Tomatoes_Rating:Q').bin(maxbins=40),
15 | alt.Color('count():Q').scale(scheme='greenblue')
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/histogram_responsive.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with Responsive Bins
3 | ------------------------------
4 | This shows an example of a histogram with bins that are responsive to a
5 | selection domain. Click and drag on the bottom panel to see the bins
6 | change on the top panel.
7 | """
8 | # category: distributions
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.flights_5k.url
13 |
14 | brush = alt.selection_interval(encodings=['x'])
15 |
16 | base = alt.Chart(source).transform_calculate(
17 | time="hours(datum.date) + minutes(datum.date) / 60"
18 | ).mark_bar().encode(
19 | y='count():Q'
20 | ).properties(
21 | width=600,
22 | height=100
23 | )
24 |
25 | alt.vconcat(
26 | base.encode(
27 | alt.X('time:Q')
28 | .bin(maxbins=30, extent=brush)
29 | .scale(domain=brush)
30 | ),
31 | base.encode(
32 | alt.X('time:Q').bin(maxbins=30),
33 | ).add_params(brush)
34 | )
35 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/histogram_scatterplot.py:
--------------------------------------------------------------------------------
1 | """
2 | 2D Histogram Scatter Plot
3 | -------------------------
4 | This example shows how to make a 2d histogram scatter plot.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | alt.X('IMDB_Rating:Q').bin(),
14 | alt.Y('Rotten_Tomatoes_Rating:Q').bin(),
15 | size='count()'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/histogram_with_a_global_mean_overlay.py:
--------------------------------------------------------------------------------
1 | """
2 | Histogram with a Global Mean Overlay
3 | ------------------------------------
4 | This example shows a histogram with a global mean overlay.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.movies.url
11 |
12 | base = alt.Chart(source)
13 |
14 | bar = base.mark_bar().encode(
15 | alt.X('IMDB_Rating:Q').bin().axis(None),
16 | y='count()'
17 | )
18 |
19 | rule = base.mark_rule(color='red').encode(
20 | x='mean(IMDB_Rating):Q',
21 | size=alt.value(5)
22 | )
23 |
24 | bar + rule
25 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/interactive_legend.py:
--------------------------------------------------------------------------------
1 | """
2 | Interactive Legend
3 | ------------------
4 | The following shows how to create a chart with an interactive legend, by
5 | binding the selection to ``"legend"``. Such a binding only works with
6 | ``selection_point`` when projected over a single field or encoding.
7 | """
8 | # category: interactive charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.unemployment_across_industries.url
13 |
14 | selection = alt.selection_point(fields=['series'], bind='legend')
15 |
16 | alt.Chart(source).mark_area().encode(
17 | alt.X('yearmonth(date):T').axis(domain=False, format='%Y', tickSize=0),
18 | alt.Y('sum(count):Q').stack('center').axis(None),
19 | alt.Color('series:N').scale(scheme='category20b'),
20 | opacity=alt.when(selection).then(alt.value(1)).otherwise(alt.value(0.2))
21 | ).add_params(
22 | selection
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/interval_selection.py:
--------------------------------------------------------------------------------
1 | """
2 | Interval Selection with Initial Date Range
3 | ==========================================
4 |
5 | This is an example of creating a stacked chart for which the domain of the
6 | top chart can be selected by interacting with the bottom chart. The initial
7 | selection range is set using Python's native datetime objects.
8 | """
9 | # category: interactive charts
10 | import altair as alt
11 | from vega_datasets import data
12 | import datetime as dt
13 |
14 | source = data.sp500.url
15 |
16 | date_range = (dt.date(2007, 6, 30), dt.date(2009, 6, 30))
17 |
18 | brush = alt.selection_interval(encodings=['x'],
19 | value={'x': date_range})
20 |
21 | base = alt.Chart(source, width=600, height=200).mark_area().encode(
22 | x = 'date:T',
23 | y = 'price:Q'
24 | )
25 |
26 | upper = base.encode(
27 | alt.X('date:T').scale(domain=brush)
28 | )
29 |
30 | lower = base.properties(
31 | height=60
32 | ).add_params(brush)
33 |
34 | upper & lower
35 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/iowa_electricity.py:
--------------------------------------------------------------------------------
1 | """
2 | Iowa's Renewable Energy Boom
3 | ----------------------------
4 | This example is a fully developed stacked chart using the sample dataset of Iowa's electricity sources.
5 | """
6 | # category: case studies
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(
13 | source,
14 | title=alt.Title(
15 | "Iowa's green energy boom",
16 | subtitle="A growing share of the state's energy has come from renewable sources"
17 | )
18 | ).mark_area().encode(
19 | alt.X("year:T").title("Year"),
20 | alt.Y("net_generation:Q")
21 | .title("Share of net generation")
22 | .stack("normalize")
23 | .axis(format=".0%"),
24 | alt.Color("source:N").title("Electricity source")
25 | )
26 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/isotype_grid.py:
--------------------------------------------------------------------------------
1 | """
2 | Isotype Grid
3 | ------------
4 | This example is a grid of isotype figures.
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | import pandas as pd
9 |
10 | data = pd.DataFrame([dict(id=i) for i in range(1, 101)])
11 |
12 | person = (
13 | "M1.7 -1.7h-0.8c0.3 -0.2 0.6 -0.5 0.6 -0.9c0 -0.6 "
14 | "-0.4 -1 -1 -1c-0.6 0 -1 0.4 -1 1c0 0.4 0.2 0.7 0.6 "
15 | "0.9h-0.8c-0.4 0 -0.7 0.3 -0.7 0.6v1.9c0 0.3 0.3 0.6 "
16 | "0.6 0.6h0.2c0 0 0 0.1 0 0.1v1.9c0 0.3 0.2 0.6 0.3 "
17 | "0.6h1.3c0.2 0 0.3 -0.3 0.3 -0.6v-1.8c0 0 0 -0.1 0 "
18 | "-0.1h0.2c0.3 0 0.6 -0.3 0.6 -0.6v-2c0.2 -0.3 -0.1 "
19 | "-0.6 -0.4 -0.6z"
20 | )
21 |
22 | alt.Chart(data).transform_calculate(
23 | row="ceil(datum.id/10)"
24 | ).transform_calculate(
25 | col="datum.id - datum.row*10"
26 | ).mark_point(
27 | filled=True,
28 | size=50
29 | ).encode(
30 | alt.X("col:O").axis(None),
31 | alt.Y("row:O").axis(None),
32 | alt.ShapeValue(person)
33 | ).properties(
34 | width=400,
35 | height=400
36 | ).configure_view(
37 | strokeWidth=0
38 | )
39 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/lasagna_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Lasagna Plot (Dense Time-Series Heatmap)
3 | ----------------------------------------
4 | """
5 | # category: tables
6 | import altair as alt
7 | from vega_datasets import data
8 |
9 | source = data.stocks()
10 |
11 | color_condition = (
12 | alt.when(alt.expr.month("datum.value") == 1, alt.expr.date("datum.value") == 1)
13 | .then(alt.value("black"))
14 | .otherwise(alt.value(None))
15 | )
16 |
17 | alt.Chart(source, width=300, height=100).transform_filter(
18 | alt.datum.symbol != "GOOG"
19 | ).mark_rect().encode(
20 | alt.X("yearmonthdate(date):O")
21 | .title("Time")
22 | .axis(
23 | format="%Y",
24 | labelAngle=0,
25 | labelOverlap=False,
26 | labelColor=color_condition,
27 | tickColor=color_condition,
28 | ),
29 | alt.Y("symbol:N").title(None),
30 | alt.Color("sum(price)").title("Price")
31 | )
32 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/layered_area_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Area Chart
3 | ------------------
4 | This example shows a layered area chart.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_area(opacity=0.3).encode(
13 | x="year:T",
14 | y=alt.Y("net_generation:Q").stack(None),
15 | color="source:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/layered_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Bar Chart
3 | -----------------
4 | This example shows a segmented bar chart that is layered rather than stacked.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_bar(opacity=0.7).encode(
13 | x='year:O',
14 | y=alt.Y('net_generation:Q').stack(None),
15 | color="source",
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/layered_chart_with_dual_axis.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered chart with Dual-Axis
3 | ----------------------------
4 | This example shows how to create a second independent y axis.
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.seattle_weather()
12 |
13 | base = alt.Chart(source).encode(
14 | alt.X('month(date):T').title(None)
15 | )
16 |
17 | area = base.mark_area(opacity=0.3, color='#57A44C').encode(
18 | alt.Y('average(temp_max)').axis(title='Avg. Temperature (°C)', titleColor='#57A44C'),
19 | alt.Y2('average(temp_min)')
20 | )
21 |
22 | line = base.mark_line(stroke='#5276A7', interpolate='monotone').encode(
23 | alt.Y('average(precipitation)').axis(title='Precipitation (inches)', titleColor='#5276A7')
24 | )
25 |
26 | alt.layer(area, line).resolve_scale(
27 | y='independent'
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/layered_heatmap_text.py:
--------------------------------------------------------------------------------
1 | """
2 | Text over a Heatmap
3 | -------------------
4 |
5 | An example of a layered chart of text over a heatmap using the cars dataset.
6 | """
7 | # category: tables
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.cars()
12 |
13 | # Configure common options. We specify the aggregation
14 | # as a transform here so we can reuse it in both layers.
15 | base = alt.Chart(source).transform_aggregate(
16 | mean_horsepower='mean(Horsepower)',
17 | groupby=['Origin', 'Cylinders']
18 | ).encode(
19 | alt.X('Cylinders:O'),
20 | alt.Y('Origin:O'),
21 | )
22 |
23 | # Configure heatmap
24 | heatmap = base.mark_rect().encode(
25 | alt.Color('mean_horsepower:Q')
26 | .scale(scheme='viridis')
27 | .title("Mean of Horsepower")
28 | )
29 |
30 | color = (
31 | alt.when(alt.datum.mean_horsepower > 150)
32 | .then(alt.value("black"))
33 | .otherwise(alt.value("white"))
34 | )
35 |
36 | # Configure text
37 | text = base.mark_text(baseline='middle').encode(
38 | alt.Text('mean_horsepower:Q', format=".0f"), color=color
39 | )
40 |
41 | # Draw the chart
42 | heatmap + text
43 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/layered_histogram.py:
--------------------------------------------------------------------------------
1 | """
2 | Layered Histogram
3 | =================
4 | This example shows how to use opacity to make a layered histogram in Altair.
5 | """
6 | # category: distributions
7 | import pandas as pd
8 | import altair as alt
9 | import numpy as np
10 | np.random.seed(42)
11 |
12 | # Generating Data
13 | source = pd.DataFrame({
14 | 'Trial A': np.random.normal(0, 0.8, 1000),
15 | 'Trial B': np.random.normal(-2, 1, 1000),
16 | 'Trial C': np.random.normal(3, 2, 1000)
17 | })
18 |
19 | alt.Chart(source).transform_fold(
20 | ['Trial A', 'Trial B', 'Trial C'],
21 | as_=['Experiment', 'Measurement']
22 | ).mark_bar(
23 | opacity=0.3,
24 | binSpacing=0
25 | ).encode(
26 | alt.X('Measurement:Q').bin(maxbins=100),
27 | alt.Y('count()').stack(None),
28 | alt.Color('Experiment:N')
29 | )
30 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_chart_with_color_datum.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Datum for Color
3 | -------------------------------
4 | An example of using ``repeat`` inside ``datum`` to color a multi-series line chart.
5 | This is adapted from this corresponding Vega-Lite Example:
6 | `Repeat and Layer to Show Different Movie Measures <https://vega.github.io/vega-lite/examples/repeat_layer.html>`_.
7 | """
8 | # category: line charts
9 |
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.movies()
14 |
15 | alt.Chart(source).mark_line().encode(
16 | alt.X("IMDB_Rating").bin(True),
17 | alt.Y(alt.repeat("layer"))
18 | .aggregate("mean")
19 | .title("Mean of US and Worldwide Gross"),
20 | color=alt.datum(alt.repeat("layer")),
21 | ).repeat(
22 | layer=["US_Gross", "Worldwide_Gross"]
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_chart_with_cumsum.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Cumulative Sum
3 | ------------------------------
4 | This chart creates a simple line chart from the cumulative sum of a fields.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.wheat()
11 |
12 | alt.Chart(source, width=600).mark_line().transform_window(
13 | # Sort the data chronologically
14 | sort=[{'field': 'year'}],
15 | # Include all previous records before the current record and none after
16 | # (This is the default value so you could skip it and it would still work.)
17 | frame=[None, 0],
18 | # What to add up as you go
19 | cumulative_wheat='sum(wheat)'
20 | ).encode(
21 | x='year:O',
22 | # Plot the calculated field created by the transformation
23 | y='cumulative_wheat:Q'
24 | )
25 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_chart_with_custom_legend.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Custom Legend
3 | -----------------------------
4 | This example uses the argmax aggregation function in order to create a custom
5 | legend for a line chart.
6 | """
7 | # category: line charts
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 |
12 | source = data.stocks()
13 |
14 | base = alt.Chart(source).encode(
15 | alt.Color("symbol").legend(None)
16 | ).transform_filter(
17 | "datum.symbol !== 'IBM'"
18 | ).properties(
19 | width=500
20 | )
21 |
22 | line = base.mark_line().encode(x="date", y="price")
23 |
24 |
25 | last_price = base.mark_circle().encode(
26 | alt.X("last_date['date']:T"),
27 | alt.Y("last_date['price']:Q")
28 | ).transform_aggregate(
29 | last_date="argmax(date)",
30 | groupby=["symbol"]
31 | )
32 |
33 | company_name = last_price.mark_text(align="left", dx=4).encode(text="symbol")
34 |
35 | chart = (line + last_price + company_name).encode(
36 | x=alt.X().title("date"),
37 | y=alt.Y().title("price")
38 | )
39 |
40 | chart
41 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_custom_order.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Custom Order
3 | ----------------------------
4 | By default, the line's path (order of points in the line) is
5 | determined by data values on the temporal/ordinal field.
6 | However, a field can be mapped to the order channel for a custom path.
7 |
8 | For example, to show a pattern of data change over time between
9 | gasoline price and average miles driven per capita we use
10 | order channel to sort the points in the line by time field (year).
11 | The earliest year (1956) is one endpoint and the latest year (2010)
12 | is the other endpoint.
13 |
14 | This is based on Hannah Fairfield's article 'Driving Shifts Into Reverse'.
15 | See https://archive.nytimes.com/www.nytimes.com/imagepages/2010/05/02/business/02metrics.html.
16 | """
17 | # category: line charts
18 | import altair as alt
19 | from vega_datasets import data
20 |
21 | source = data.driving()
22 |
23 | alt.Chart(source).mark_line(point=True).encode(
24 | x=alt.X("miles").scale(zero=False),
25 | y=alt.Y("gas").scale(zero=False),
26 | order="year",
27 | tooltip=["miles", "gas", "year"],
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_percent.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Percent axis
3 | ----------------------------
4 | This example shows how to format the tick labels of the y-axis of a chart as percentages.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.jobs.url
11 |
12 | alt.Chart(source).mark_line().encode(
13 | alt.X('year:O'),
14 | alt.Y('perc:Q').axis(format='%'),
15 | alt.Color('sex:N')
16 | ).transform_filter(
17 | alt.datum.job == 'Welder'
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Confidence Interval Band
3 | ----------------------------------------
4 | How to make a line chart with a bootstrapped 95% confidence interval band.
5 | """
6 | # category: uncertainties and trends
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.cars()
11 |
12 | line = alt.Chart(source).mark_line().encode(
13 | x='Year',
14 | y='mean(Miles_per_Gallon)'
15 | )
16 |
17 | band = alt.Chart(source).mark_errorband(extent='ci').encode(
18 | x='Year',
19 | y=alt.Y('Miles_per_Gallon').title('Miles/Gallon'),
20 | )
21 |
22 | band + line
23 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_with_last_value_labeled.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Last Value Labeled
3 | ----------------------------------
4 | This chart shows a line chart with a label annotating the final value
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | # Import example data
11 | source = data.stocks()
12 |
13 | # Create a common chart object
14 | chart = alt.Chart(source).transform_filter(
15 | alt.datum.symbol != "IBM" # A reducation of the dataset to clarify our example. Not required.
16 | ).encode(
17 | alt.Color("symbol").legend(None)
18 | )
19 |
20 | # Draw the line
21 | line = chart.mark_line().encode(
22 | x="date:T",
23 | y="price:Q"
24 | )
25 |
26 | # Use the `argmax` aggregate to limit the dataset to the final value
27 | label = chart.encode(
28 | x='max(date):T',
29 | y=alt.Y('price:Q').aggregate(argmax='date'),
30 | text='symbol'
31 | )
32 |
33 | # Create a text label
34 | text = label.mark_text(align='left', dx=4)
35 |
36 | # Create a circle annotation
37 | circle = label.mark_circle()
38 |
39 | # Draw the chart with all the layers combined
40 | line + circle + text
41 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/line_with_log_scale.py:
--------------------------------------------------------------------------------
1 | """
2 | Line Chart with Logarithmic Scale
3 | ---------------------------------
4 | How to make a line chart on a `Logarithmic scale <https://en.wikipedia.org/wiki/Logarithmic_scale>`_.
5 | """
6 | # category: line charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.population()
11 |
12 | alt.Chart(source).mark_line().encode(
13 | x='year:O',
14 | y=alt.Y('sum(people)').scale(type="log")
15 | )
16 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/multifeature_scatter_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Multifeature Scatter Plot
3 | =========================
4 | This example shows how to make a scatter plot with multiple feature encodings.
5 | """
6 | # category: scatter plots
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iris()
11 |
12 | alt.Chart(source).mark_circle().encode(
13 | alt.X('sepalLength').scale(zero=False),
14 | alt.Y('sepalWidth').scale(zero=False, padding=1),
15 | color='species',
16 | size='petalWidth'
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/multiline_highlight.py:
--------------------------------------------------------------------------------
1 | """
2 | Multi-Line Highlight
3 | ====================
4 | This multi-line chart uses an invisible Voronoi tessellation to handle pointerover to
5 | identify the nearest point and then highlight the line on which the point falls.
6 | It is adapted from the Vega-Lite example found at
7 | https://bl.ocks.org/amitkaps/fe4238e716db53930b2f1a70d3401701
8 | """
9 | # category: interactive charts
10 | import altair as alt
11 | from vega_datasets import data
12 |
13 | source = data.stocks()
14 |
15 | highlight = alt.selection_point(on='pointerover', fields=['symbol'], nearest=True)
16 |
17 | base = alt.Chart(source).encode(
18 | x='date:T',
19 | y='price:Q',
20 | color='symbol:N'
21 | )
22 |
23 | points = base.mark_circle().encode(
24 | opacity=alt.value(0)
25 | ).add_params(
26 | highlight
27 | ).properties(
28 | width=600
29 | )
30 |
31 | lines = base.mark_line().encode(
32 | size=alt.when(~highlight).then(alt.value(1)).otherwise(alt.value(3))
33 | )
34 |
35 | points + lines
36 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/normalized_stacked_area_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Normalized Stacked Area Chart
3 | -----------------------------
4 | This example shows how to make a normalized stacked area chart.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.iowa_electricity()
11 |
12 | alt.Chart(source).mark_area().encode(
13 | x="year:T",
14 | y=alt.Y("net_generation:Q").stack("normalize"),
15 | color="source:N"
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/normalized_stacked_bar_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Normalized Stacked Bar Chart
3 | ----------------------------
4 | This is an example of a normalized stacked bar chart using data which contains crop yields over different regions and different years in the 1930s.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x=alt.X('sum(yield)').stack("normalize"),
14 | y='variety',
15 | color='site'
16 | )
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/pacman_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Pacman Chart
3 | ------------
4 | Chart made using ``mark_arc`` and constant values.
5 | This could also be made using
6 | ``alt.Chart(source).mark_arc(color = "gold", theta = (5/8)*np.pi, theta2 = (19/8)*np.pi,radius=100)``.
7 | """
8 | # category: circular plots
9 |
10 | import numpy as np
11 | import altair as alt
12 |
13 | alt.Chart().mark_arc(color="gold").encode(
14 | theta=alt.ThetaDatum((5 / 8) * np.pi).scale(None),
15 | theta2=alt.Theta2Datum((19 / 8) * np.pi),
16 | radius=alt.RadiusDatum(100).scale(None),
17 | )
18 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/parallel_coordinates.py:
--------------------------------------------------------------------------------
1 | """
2 | Parallel Coordinates
3 | --------------------
4 | A `Parallel Coordinates <https://en.wikipedia.org/wiki/Parallel_coordinates>`_
5 | chart is a chart that lets you visualize the individual data points by drawing
6 | a single line for each of them.
7 | Such a chart can be created in Altair by first transforming the data into a
8 | suitable representation.
9 | This example shows a parallel coordinates chart with the Iris dataset.
10 | """
11 | # category: advanced calculations
12 |
13 | import altair as alt
14 | from vega_datasets import data
15 |
16 | source = data.iris()
17 |
18 | alt.Chart(source, width=500).transform_window(
19 | index='count()'
20 | ).transform_fold(
21 | ['petalLength', 'petalWidth', 'sepalLength', 'sepalWidth']
22 | ).mark_line().encode(
23 | x='key:N',
24 | y='value:Q',
25 | color='species:N',
26 | detail='index:N',
27 | opacity=alt.value(0.5)
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/percentage_of_total.py:
--------------------------------------------------------------------------------
1 | """
2 | Calculating Percentage of Total
3 | -------------------------------
4 | This chart demonstrates how to use a joinaggregate transform to display
5 | data values as a percentage of total.
6 | """
7 | # category: bar charts
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame({
12 | 'Activity': ['Sleeping', 'Eating', 'TV', 'Work', 'Exercise'],
13 | 'Time': [8, 2, 4, 8, 2]
14 | })
15 |
16 | alt.Chart(source).transform_joinaggregate(
17 | TotalTime='sum(Time)',
18 | ).transform_calculate(
19 | PercentOfTotal="datum.Time / datum.TotalTime"
20 | ).mark_bar().encode(
21 | alt.X('PercentOfTotal:Q').axis(format='.0%'),
22 | y='Activity:N'
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/pie_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Pie Chart
3 | ---------
4 | This example shows how to make a Pie Chart using ``mark_arc``.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Pie Chart <https://vega.github.io/vega-lite/examples/arc_pie.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({"category": [1, 2, 3, 4, 5, 6], "value": [4, 6, 10, 3, 7, 8]})
14 |
15 | alt.Chart(source).mark_arc().encode(
16 | theta="value",
17 | color="category"
18 | )
19 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/pie_chart_with_labels.py:
--------------------------------------------------------------------------------
1 | """
2 | Pie Chart with Labels
3 | ---------------------
4 | This example shows how to layer text over arc marks (``mark_arc``) to label pie charts.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Pie Chart with Labels <https://vega.github.io/vega-lite/examples/layer_arc_label.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame(
14 | {"category": ["a", "b", "c", "d", "e", "f"], "value": [4, 6, 10, 3, 7, 8]}
15 | )
16 |
17 | base = alt.Chart(source).encode(
18 | alt.Theta("value:Q").stack(True),
19 | alt.Color("category:N").legend(None)
20 | )
21 |
22 | pie = base.mark_arc(outerRadius=120)
23 | text = base.mark_text(radius=140, size=20).encode(text="category:N")
24 |
25 | pie + text
26 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/poly_fit_regression.py:
--------------------------------------------------------------------------------
1 | """
2 | Polynomial Fit Plot with Regression Transform
3 | =============================================
4 | This example shows how to overlay data with multiple fitted polynomials using
5 | the regression transform.
6 | """
7 | # category: uncertainties and trends
8 |
9 | import numpy as np
10 | import pandas as pd
11 | import altair as alt
12 |
13 | # Generate some random data
14 | rng = np.random.RandomState(1)
15 | x = rng.rand(40) ** 2
16 | y = 10 - 1.0 / (x + 0.1) + rng.randn(40)
17 | source = pd.DataFrame({"x": x, "y": y})
18 |
19 | # Define the degree of the polynomial fits
20 | degree_list = [1, 3, 5]
21 |
22 | base = alt.Chart(source).mark_circle(color="black").encode(
23 | alt.X("x"),
24 | alt.Y("y")
25 | )
26 |
27 | polynomial_fit = [
28 | base.transform_regression(
29 | "x", "y", method="poly", order=order, as_=["x", str(order)]
30 | )
31 | .mark_line()
32 | .transform_fold([str(order)], as_=["degree", "y"])
33 | .encode(alt.Color("degree:N"))
34 | for order in degree_list
35 | ]
36 |
37 | alt.layer(base, *polynomial_fit)
38 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/pyramid.py:
--------------------------------------------------------------------------------
1 | """
2 | Pyramid Pie Chart
3 | -----------------
4 | Altair reproduction of http://robslink.com/SAS/democd91/pyramid_pie.htm
5 | """
6 | # category: case studies
7 | import altair as alt
8 | import pandas as pd
9 |
10 | category = ['Sky', 'Shady side of a pyramid', 'Sunny side of a pyramid']
11 | color = ["#416D9D", "#674028", "#DEAC58"]
12 | df = pd.DataFrame({'category': category, 'value': [75, 10, 15]})
13 |
14 | alt.Chart(df, width=150, height=150).mark_arc(outerRadius=80).encode(
15 | alt.Theta('value:Q').scale(range=[2.356, 8.639]),
16 | alt.Color('category:N')
17 | .title(None)
18 | .scale(domain=category, range=color)
19 | .legend(orient='none', legendX=160, legendY=50),
20 | order='value:Q'
21 | ).configure_view(
22 | strokeOpacity=0
23 | )
24 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/radial_chart.py:
--------------------------------------------------------------------------------
1 | """
2 | Radial Chart
3 | ------------
4 | This radial plot uses both angular and radial extent to convey multiple dimensions of data.
5 | This is adapted from a corresponding Vega-Lite Example:
6 | `Radial Plot <https://vega.github.io/vega-lite/examples/arc_radial.html>`_.
7 | """
8 | # category: circular plots
9 |
10 | import pandas as pd
11 | import altair as alt
12 |
13 | source = pd.DataFrame({"values": [12, 23, 47, 6, 52, 19]})
14 |
15 | base = alt.Chart(source).encode(
16 | alt.Theta("values:Q").stack(True),
17 | alt.Radius("values").scale(type="sqrt", zero=True, rangeMin=20),
18 | color="values:N",
19 | )
20 |
21 | c1 = base.mark_arc(innerRadius=20, stroke="#fff")
22 |
23 | c2 = base.mark_text(radiusOffset=10).encode(text="values:Q")
24 |
25 | c1 + c2
26 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/ranged_dot_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Ranged Dot Plot
3 | ---------------
4 | This example shows a ranged dot plot to convey changing life expectancy for the five most populous countries (between 1955 and 2000).
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.countries.url
11 |
12 | chart = (
13 | alt.Chart(source)
14 | .encode(x="life_expect:Q", y="country:N")
15 | .transform_filter(
16 | alt.FieldOneOfPredicate(
17 | field="country",
18 | oneOf=["China", "India", "United States", "Indonesia", "Brazil"],
19 | )
20 | )
21 | .transform_filter(alt.FieldOneOfPredicate(field="year", oneOf=[1955, 2000]))
22 | )
23 |
24 | line = chart.mark_line(color="#db646f").encode(detail="country:N")
25 |
26 | # Add points for life expectancy in 1955 & 2000
27 | color = alt.Color("year:O").scale(domain=[1955, 2000], range=["#e6959c", "#911a24"])
28 | points = (
29 | chart.mark_point(
30 | size=100,
31 | opacity=1,
32 | filled=True,
33 | )
34 | .encode(color=color)
35 | .interactive()
36 | )
37 |
38 | (line + points)
39 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/scatter_with_rolling_mean.py:
--------------------------------------------------------------------------------
1 | """
2 | Scatter Plot with Rolling Mean
3 | ------------------------------
4 | A scatter plot with a rolling mean overlay. In this example a 30 day window
5 | is used to calculate the mean of the maximum temperature around each date.
6 | """
7 | # category: scatter plots
8 |
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.seattle_weather()
13 |
14 | line = alt.Chart(source).mark_line(
15 | color='red',
16 | size=3
17 | ).transform_window(
18 | rolling_mean='mean(temp_max)',
19 | frame=[-15, 15]
20 | ).encode(
21 | x='date:T',
22 | y='rolling_mean:Q'
23 | )
24 |
25 | points = alt.Chart(source).mark_point().encode(
26 | x='date:T',
27 | y=alt.Y('temp_max:Q').title('Max Temp')
28 | )
29 |
30 | points + line
31 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/simple_scatter_with_errorbars.py:
--------------------------------------------------------------------------------
1 | """
2 | Simple Scatter Plot with Errorbars
3 | ----------------------------------
4 | A simple scatter plot of a data set with errorbars.
5 | """
6 | # category: uncertainties and trends
7 | import altair as alt
8 | import pandas as pd
9 | import numpy as np
10 |
11 | # generate some data points with uncertainties
12 | np.random.seed(0)
13 | x = [1, 2, 3, 4, 5]
14 | y = np.random.normal(10, 0.5, size=len(x))
15 | yerr = 0.2
16 |
17 | # set up data frame
18 | source = pd.DataFrame({"x": x, "y": y, "yerr": yerr})
19 |
20 | # the base chart
21 | base = alt.Chart(source).transform_calculate(
22 | ymin="datum.y-datum.yerr",
23 | ymax="datum.y+datum.yerr"
24 | )
25 |
26 | # generate the points
27 | points = base.mark_point(
28 | filled=True,
29 | size=50,
30 | color='black'
31 | ).encode(
32 | alt.X('x').scale(domain=(0, 6)),
33 | alt.Y('y').scale(zero=False)
34 | )
35 |
36 | # generate the error bars
37 | errorbars = base.mark_errorbar().encode(
38 | x="x",
39 | y="ymin:Q",
40 | y2="ymax:Q"
41 | )
42 |
43 | points + errorbars
44 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/sorted_error_bars_with_ci.py:
--------------------------------------------------------------------------------
1 | """
2 | Sorted Error Bars showing Confidence Interval
3 | =============================================
4 | This example shows how to show error bars using confidence intervals, while also sorting the y-axis based on x-axis values.
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.barley()
12 |
13 | points = alt.Chart(source).mark_point(
14 | filled=True,
15 | color='black'
16 | ).encode(
17 | x=alt.X('mean(yield)').title('Barley Yield'),
18 | y=alt.Y('variety').sort(
19 | field='yield',
20 | op='mean',
21 | order='descending'
22 | )
23 | ).properties(
24 | width=400,
25 | height=250
26 | )
27 |
28 | error_bars = points.mark_rule().encode(
29 | x='ci0(yield)',
30 | x2='ci1(yield)',
31 | )
32 |
33 | points + error_bars
34 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/stacked_bar_chart_sorted_segments.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Bar Chart with Sorted Segments
3 | --------------------------------------
4 | This is an example of a stacked-bar chart with the segments of each bar resorted.
5 | """
6 | # category: bar charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.barley()
11 |
12 | alt.Chart(source).mark_bar().encode(
13 | x='sum(yield)',
14 | y='variety',
15 | color='site',
16 | order=alt.Order(
17 | # Sort the segments of the bars by this field
18 | 'site',
19 | sort='ascending'
20 | )
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/stacked_bar_chart_with_text.py:
--------------------------------------------------------------------------------
1 | """
2 | Stacked Bar Chart with Text Overlay
3 | ===================================
4 | This example shows how to overlay text on a stacked bar chart. For both the
5 | bar and text marks, we use the ``stack`` argument in the ``x`` encoding to
6 | cause the values to be stacked horizontally.
7 | """
8 | # category: bar charts
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source=data.barley()
13 |
14 | bars = alt.Chart(source).mark_bar().encode(
15 | x=alt.X('sum(yield):Q').stack('zero'),
16 | y=alt.Y('variety:N'),
17 | color=alt.Color('site')
18 | )
19 |
20 | text = alt.Chart(source).mark_text(dx=-15, dy=3, color='white').encode(
21 | x=alt.X('sum(yield):Q').stack('zero'),
22 | y=alt.Y('variety:N'),
23 | detail='site:N',
24 | text=alt.Text('sum(yield):Q', format='.1f')
25 | )
26 |
27 | bars + text
28 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/stem_and_leaf.py:
--------------------------------------------------------------------------------
1 | """
2 | Stem and Leaf Plot
3 | ------------------
4 | This example shows how to make a stem and leaf plot.
5 | """
6 | # category: advanced calculations
7 | import altair as alt
8 | import pandas as pd
9 | import numpy as np
10 | np.random.seed(42)
11 |
12 | # Generating random data
13 | source = pd.DataFrame({'samples': np.random.normal(50, 15, 100).astype(int).astype(str)})
14 |
15 | # Splitting stem and leaf
16 | source['stem'] = source['samples'].str[:-1]
17 | source['leaf'] = source['samples'].str[-1]
18 |
19 | source = source.sort_values(by=['stem', 'leaf'])
20 |
21 | # Determining leaf position
22 | source['position'] = source.groupby('stem').cumcount().add(1)
23 |
24 | # Creating stem and leaf plot
25 | alt.Chart(source).mark_text(
26 | align='left',
27 | baseline='middle',
28 | dx=-5
29 | ).encode(
30 | alt.X('position:Q')
31 | .title('')
32 | .axis(ticks=False, labels=False, grid=False),
33 | alt.Y('stem:N')
34 | .title('')
35 | .axis(tickSize=0),
36 | text='leaf:N',
37 | ).configure_axis(
38 | labelFontSize=20
39 | ).configure_text(
40 | fontSize=20
41 | )
42 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/streamgraph.py:
--------------------------------------------------------------------------------
1 | """
2 | Streamgraph
3 | -----------------
4 | This example shows the streamgraph from vega-lite examples.
5 | """
6 | # category: area charts
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | source = data.unemployment_across_industries.url
11 |
12 | alt.Chart(source).mark_area().encode(
13 | alt.X('yearmonth(date):T').axis(format='%Y', domain=False, tickSize=0),
14 | alt.Y('sum(count):Q').stack('center').axis(None),
15 | alt.Color('series:N').scale(scheme='category20b')
16 | ).interactive()
17 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/top_k_items.py:
--------------------------------------------------------------------------------
1 | """
2 | Top K Items
3 | -----------
4 | This example shows how to use the window and transformation filter to display
5 | the Top items of a long list of items in decreasing order.
6 | Here we sort the top 10 highest ranking movies of IMDB.
7 | """
8 | # category: advanced calculations
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.movies.url
13 |
14 | # Top 10 movies by IMBD rating
15 | alt.Chart(
16 | source,
17 | ).mark_bar().encode(
18 | alt.X('Title:N').sort('-y'),
19 | alt.Y('IMDB_Rating:Q'),
20 | alt.Color('IMDB_Rating:Q')
21 |
22 | ).transform_window(
23 | rank='rank(IMDB_Rating)',
24 | sort=[alt.SortField('IMDB_Rating', order='descending')]
25 | ).transform_filter(
26 | (alt.datum.rank < 10)
27 | )
28 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/top_k_with_others.py:
--------------------------------------------------------------------------------
1 | """
2 | Top-K Plot with Others
3 | ----------------------
4 | This example shows how to use aggregate, window, and calculate transformations
5 | to display the top-k directors by average worldwide gross while grouping the
6 | remaining directors as 'All Others'.
7 | """
8 | # category: advanced calculations
9 | import altair as alt
10 | from vega_datasets import data
11 |
12 | source = data.movies.url
13 |
14 | alt.Chart(source).mark_bar().encode(
15 | alt.X("aggregate_gross:Q").aggregate("mean").title(None),
16 | alt.Y("ranked_director:N")
17 | .sort(op="mean", field="aggregate_gross", order="descending")
18 | .title(None)
19 | ).transform_aggregate(
20 | aggregate_gross='mean(Worldwide_Gross)',
21 | groupby=["Director"],
22 | ).transform_window(
23 | rank='row_number()',
24 | sort=[alt.SortField("aggregate_gross", order="descending")],
25 | ).transform_calculate(
26 | ranked_director="datum.rank < 10 ? datum.Director : 'All Others'"
27 | ).properties(
28 | title="Top Directors by Average Worldwide Gross",
29 | )
30 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/us_population_over_time_facet.py:
--------------------------------------------------------------------------------
1 | """
2 | US Population: Wrapped Facet
3 | ============================
4 | This chart visualizes the age distribution of the US population over time,
5 | using a wrapped faceting of the data by decade.
6 | """
7 | # category: case studies
8 | import altair as alt
9 | from vega_datasets import data
10 |
11 | source = data.population.url
12 |
13 | alt.Chart(source).mark_area().encode(
14 | x='age:O',
15 | y=alt.Y('sum(people):Q').title('Population').axis(format='~s'),
16 | facet=alt.Facet('year:O').columns(5),
17 | ).properties(
18 | title='US Age Distribution By Year',
19 | width=90,
20 | height=80
21 | )
22 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/violin_plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Violin Plot
3 | -----------
4 | This example shows how to make a Violin Plot using Altair's density transform.
5 | """
6 | # category: distributions
7 | import altair as alt
8 | from vega_datasets import data
9 |
10 | alt.Chart(data.cars(), width=100).transform_density(
11 | 'Miles_per_Gallon',
12 | as_=['Miles_per_Gallon', 'density'],
13 | extent=[5, 50],
14 | groupby=['Origin']
15 | ).mark_area(orient='horizontal').encode(
16 | alt.X('density:Q')
17 | .stack('center')
18 | .impute(None)
19 | .title(None)
20 | .axis(labels=False, values=[0], grid=False, ticks=True),
21 | alt.Y('Miles_per_Gallon:Q'),
22 | alt.Color('Origin:N'),
23 | alt.Column('Origin:N')
24 | .spacing(0)
25 | .header(titleOrient='bottom', labelOrient='bottom', labelPadding=0)
26 | ).configure_view(
27 | stroke=None
28 | )
29 |
--------------------------------------------------------------------------------
/tests/examples_methods_syntax/wilkinson-dot-plot.py:
--------------------------------------------------------------------------------
1 | """
2 | Wilkinson Dot Plot
3 | ------------------
4 | An example of a `Wilkinson Dot Plot <https://en.wikipedia.org/wiki/Dot_plot_(statistics)>`_
5 | """
6 | # category: advanced calculations
7 |
8 | import altair as alt
9 | import pandas as pd
10 |
11 | source = pd.DataFrame(
12 | {"data":[1,1,1,1,1,1,1,1,1,1,
13 | 2,2,2,
14 | 3,3,
15 | 4,4,4,4,4,4]
16 | }
17 | )
18 |
19 | alt.Chart(source, height=100).mark_circle(opacity=1).transform_window(
20 | id='rank()',
21 | groupby=['data']
22 | ).encode(
23 | alt.X('data:O'),
24 | alt.Y('id:O').axis(None).sort('descending')
25 | )
26 |
--------------------------------------------------------------------------------
/tests/expr/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/tests/expr/__init__.py
--------------------------------------------------------------------------------
/tests/test_toplevel.py:
--------------------------------------------------------------------------------
1 | import altair as alt
2 | from tools import update_init_file
3 |
4 |
5 | def test_completeness_of__all__():
6 | relevant_attributes = update_init_file.relevant_attributes(alt.__dict__)
7 |
8 | # If the assert statement fails below, there are probably either new objects
9 | # in the top-level Altair namespace or some were removed.
10 | # In that case, run `hatch run update-init-file` to update __all__
11 | assert alt.__all__ == relevant_attributes
12 |
--------------------------------------------------------------------------------
/tests/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/tests/utils/__init__.py
--------------------------------------------------------------------------------
/tests/utils/test_execeval.py:
--------------------------------------------------------------------------------
1 | from altair.utils.execeval import eval_block
2 |
3 | HAS_RETURN = """
4 | x = 4
5 | y = 2 * x
6 | 3 * y
7 | """
8 |
9 | NO_RETURN = """
10 | x = 4
11 | y = 2 * x
12 | z = 3 * y
13 | """
14 |
15 |
16 | def test_eval_block_with_return():
17 | _globals = {}
18 | result = eval_block(HAS_RETURN, _globals)
19 | assert result == 24
20 | assert _globals["x"] == 4
21 | assert _globals["y"] == 8
22 |
23 |
24 | def test_eval_block_without_return():
25 | _globals = {}
26 | result = eval_block(NO_RETURN, _globals)
27 | assert result is None
28 | assert _globals["x"] == 4
29 | assert _globals["y"] == 8
30 | assert _globals["z"] == 24
31 |
--------------------------------------------------------------------------------
/tests/utils/test_server.py:
--------------------------------------------------------------------------------
1 | """Test http server."""
2 |
3 | from altair.utils.server import MockServer, serve
4 | from tests import slow
5 |
6 |
7 | @slow
8 | def test_serve():
9 | html = "<html><title>Title</title><body><p>Content</p></body></html>"
10 | serve(html, open_browser=False, http_server=MockServer)
11 |
--------------------------------------------------------------------------------
/tests/vegalite/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/tests/vegalite/__init__.py
--------------------------------------------------------------------------------
/tests/vegalite/v6/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/tests/vegalite/v6/__init__.py
--------------------------------------------------------------------------------
/tests/vegalite/v6/schema/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vega/altair/3d05d6b0a7c9d0d7afad6e903f903a7d2c03a3d9/tests/vegalite/v6/schema/__init__.py
--------------------------------------------------------------------------------
/tests/vegalite/v6/test_alias.py:
--------------------------------------------------------------------------------
1 | import pytest
2 |
3 | import altair.vegalite.v6 as alt
4 |
5 |
6 | def test_aliases():
7 | """Ensure that any aliases defined in `api.py` aren't colliding with names already defined in `core.py` or `channels.py`."""
8 | for alias in ["Bin", "Impute", "Title"]:
9 | # this test pass if the alias can resolve to its real name
10 | try:
11 | getattr(alt, alias)
12 | except AttributeError as err:
13 | msg = f"cannot resolve '{alias}':, {err}"
14 | raise AssertionError(msg) from err
15 |
16 | # this test fails if the alias match a colliding name in core
17 | with pytest.raises(AttributeError):
18 | getattr(alt.core, alias)
19 |
20 | # this test fails if the alias match a colliding name in channels
21 | with pytest.raises(AttributeError):
22 | getattr(alt.channels, alias)
23 |
--------------------------------------------------------------------------------
/tests/vegalite/v6/test_data.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 |
3 | import pandas as pd
4 | import pytest
5 |
6 | from altair.vegalite.v6 import data as alt
7 |
8 |
9 | @pytest.fixture
10 | def sample_data():
11 | return pd.DataFrame({"x": range(10), "y": range(10)})
12 |
13 |
14 | def test_disable_max_rows(sample_data):
15 | with alt.data_transformers.enable("default", max_rows=5):
16 | # Ensure max rows error is raised.
17 | with pytest.raises(alt.MaxRowsError):
18 | alt.data_transformers.get()(sample_data)
19 |
20 | # Ensure that max rows error is properly disabled.
21 | with alt.data_transformers.disable_max_rows():
22 | alt.data_transformers.get()(sample_data)
23 |
24 | try:
25 | # Ensure that there is no TypeError for non-max_rows transformers.
26 | with (
27 | alt.data_transformers.enable("json"),
28 | alt.data_transformers.disable_max_rows(),
29 | ):
30 | jsonfile = alt.data_transformers.get()(sample_data)
31 | except TypeError:
32 | jsonfile = {}
33 | finally:
34 | if jsonfile:
35 | Path(jsonfile["url"]).unlink()
36 |
--------------------------------------------------------------------------------
/tests/vegalite/v6/test_layer_props.py:
--------------------------------------------------------------------------------
1 | import pytest
2 |
3 | import altair.vegalite.v6 as alt
4 |
5 |
6 | def test_layer_props():
7 | """Beginning in Vega-Lite v6, the properties "height" and "width" were no longer allowed in a subchart within a LayerChart. We check here that these are moved to the top level by Altair."""
8 | base = alt.Chart().mark_point()
9 |
10 | # Allowed
11 | base.properties(width=100) + base
12 | base.properties(width=100) + base.properties(height=200)
13 | base.properties(width=100) + base.properties(height=200, width=100)
14 |
15 | # Not allowed
16 | with pytest.raises(ValueError, match="inconsistent"):
17 | base.properties(width=100) + base.properties(width=200)
18 |
19 | # Check that the resulting LayerChart has the correct properties.
20 | c = base.properties(width=100) + base.properties(height=200, width=100)
21 | assert isinstance(c, alt.LayerChart)
22 | assert c.width == 100
23 | assert c.height == 200
24 |
--------------------------------------------------------------------------------
/tools/__init__.py:
--------------------------------------------------------------------------------
1 | from tools import (
2 | fs,
3 | generate_api_docs,
4 | generate_schema_wrapper,
5 | markup,
6 | schemapi,
7 | update_init_file,
8 | versioning,
9 | )
10 |
11 | __all__ = [
12 | "fs",
13 | "generate_api_docs",
14 | "generate_schema_wrapper",
15 | "markup",
16 | "schemapi",
17 | "update_init_file",
18 | "versioning",
19 | ]
20 |
--------------------------------------------------------------------------------
/tools/schemapi/__init__.py:
--------------------------------------------------------------------------------
1 | """schemapi: tools for generating Python APIs from JSON schemas."""
2 |
3 | from tools.schemapi import codegen, utils
4 | from tools.schemapi.codegen import (
5 | CodeSnippet,
6 | arg_invalid_kwds,
7 | arg_kwds,
8 | arg_required_kwds,
9 | )
10 | from tools.schemapi.schemapi import SchemaBase, Undefined
11 | from tools.schemapi.utils import OneOrSeq, SchemaInfo
12 | from tools.vega_expr import write_expr_module
13 |
14 | __all__ = [
15 | "CodeSnippet",
16 | "OneOrSeq",
17 | "SchemaBase",
18 | "SchemaInfo",
19 | "Undefined",
20 | "arg_invalid_kwds",
21 | "arg_kwds",
22 | "arg_required_kwds",
23 | "codegen",
24 | "utils",
25 | "write_expr_module",
26 | ]
27 |
--------------------------------------------------------------------------------