Skip to main content
Python Software Foundation 20th Year Anniversary Fundraiser  Donate today!

Visualization recommendation using constraints

Project description

<p align="center">
<a href="">
<img src="logos/dark/logo-dark.png" width=260></img>

# Formalizing Visualization Design Knowledge as Constraints

[![Build Status](](
[![Coverage Status](](
[![Code style: black](](
[![code style: prettier](](

Draco is a formal framework for representing design knowledge about effective visualization design as a collection of constraints. You can use Draco to find effective visualization visual designs in Vega-Lite. Draco's constraints are implemented in based on Answer Set Programming (ASP) and solved with the Clingo constraint solver. We also implemented a way to learn weights for the recommendation system directly from the results of graphical perception experiment.

Read our introductory [blog post about Draco]( and our [research paper]( for more details. Try Draco in the browser at

## Status

**There Be Dragons!** This project is in active development and we are working hard on cleaning up the repository and making it easier to use the recommendation model in Draco. If you want to use this right now, please talk to us. More documentation is forthcoming.

## Overview

This repository currently contains:

* [**draco**]( (pypi) The ASP programs with soft and hard constraints, a python API for [running Draco](, the [CLI](, and the [python wrapper]( for the **draco-core** API. Additionally includes some [helper functions]( that may prove useful.
* [**draco-core**]( (npm) Holds a Typescript / Javascript friendly copy of the ASP programs, and additionally, a Typescript /Javascript API for all the translation logic of Draco, as described below.

### Sibling Repositories

Various functionality and extensions are in the following repositories

* [draco-vis](
* A web-friendly Draco! Including a bundled Webassembly module of Draco's solver, Clingo.

* [draco-learn](
* Runs a learning-to-rank method on results of perception experiments.

* [draco-tools](
* UI tools to create annotated datasets of pairs of visualizations, look at the recommendations, and to explore large datasets of example visualizations.

* [draco-analysis](
* Notebooks to analyze the results.

## Draco API (Python)

In addition to a wrapper of the Draco-Core API describe below, the python API contains the following functions.

*object* **Result** [<>](

>The result of a Draco run, a solution to a draco_query. User `result.as_vl()` to convert this solution into a Vega-Lite specification.

**run** *(draco_query: List[str] [,constants, files, relax_hard, silence_warnings, debug, clear_cache]) -> Result:* [<>](

>Runs a `draco_query`, defined as a list of Draco ASP facts (strings), against given `file` asp programs (defaults to base Draco set). Returns a `Result` if the query is satisfiable. If `relax_hard` is set to `True`, hard constraints (`hard.lp`) will not be strictly enforced, and instead will incur an infinite cost when violated.

**is_valid** *(draco_query: List[str] [,debug]) -> bool:* [<>](

>Runs a `draco_query`, defined as a list of Draco ASP facts (strings), against Draco's hard constraints. Returns true if the visualization defined by the query is a valid one (does not violate hard constraints), and false otherwise. Hard constraints can be found in [`hard.lp`](

**data_to_asp** *(data: List) -> List[str]:* [<>](

>Reads an array of `data` and returns the ASP declaration of it (a list of facts).

**read_data_to_asp** *(file: str) -> List[str]:* [<>](

>Reads a `file` of data (either `.json` or `.csv`) and returns the ASP declaration of it (a list of facts).

## Draco-Core API (Typescript / Javascript)

**vl2asp** *(spec: TopLevelUnitSpec): string[]* [<>](

>Translates a Vega-Lite specification into a list of ASP Draco facts.

**cql2asp** *(spec: any): string[]* [<>](

>Translates a CompassQL specification into a list of ASP Draco constraints.

**asp2vl** *(facts: string[]): TopLevelUnitSpec* [<>](

>Interprets a list of ASP Draco facts as a Vega-Lite specification.

**data2schema** *(data: any[]): Schema* [<>](

>Reads a list of rows and generates a data schema for the dataset. `data` should be given as a list of dictionaries.

**schema2asp** *(schema: Schema): string[]* [<>](

>Translates a data schema into an ASP declaration of the data it describes.

**constraints2json** *(constraintsAsp: string, weightsAsp?: string): Constraint[]* [<>](

>Translates the given ASP constraints and matching weights (i.e. for soft constraints) into JSON format.

**json2constraints** *(constraints: Constraint[]): ConstraintAsp* [<>](

>Translates the given JSON format ASP constraints into ASP strings for definitions and weights (if applicable, i.e. for soft constraints).

## User Info

### Installation

#### Python (Draco API)

##### Install Clingo

You can install Clingo with conda: `conda install -c potassco clingo`. On MacOS, you can alternatively run `brew install clingo`.

##### Install Draco (Python)

`pip install draco`

#### Typescript / Javascript (Draco-Core API)

**STOP!** If you wish to **run** Draco in a **web browser**, consider using [**draco-vis**](, which bundles the Clingo solver as a WebAssembly module. The Draco-Core API does not include this functionality by itself. It merely handles the logic of translating between the various interface languages.

`yarn add draco-core` or `npm install draco-core`

## Developer Info

### Installation

#### Install Clingo.

You can install Clingo with conda: `conda install -c potassco clingo`. On MacOS, you can alternatively run `brew install clingo`.

#### Install node dependencies

`yarn` or `npm install`

You might need to activate a Python 2.7 environment to compile the canvas module.

#### Build JS module

`yarn build`

#### Python setup

`pip install -r requirements.txt` or `conda install --file requirements.txt`

Install Draco in editable mode. We expect Python 3.

`pip install -e .`

Now you can call the command line tool `draco`. For example `draco --version` or `draco --help`.

#### Tests

You should also be able to run the tests (and coverage report)

`python test`

##### Run only ansunit tests

`ansunit asp/tests.yaml`

##### Run only python tests

`pytest -v`

##### Test types

`mypy draco tests --ignore-missing-imports`

### Running Draco

#### End to end example

To run Draco on a partial spec.

`sh spec`

The output would be a .vl.json file (for Vega-Lite spec) and a .png file to preview the visualization (by default, outputs would be in folder `__tmp__`).

#### Use CompassQL to generate examples

Run `yarn build_cql_examples`.

#### Run Draco directly on a set of ASP constraints

You can use the helper file `asp/_all.lp`.

`clingo asp/_all.lp test.lp`

Alternatively, you can invoke Draco with `draco -m asp test.lp`.

#### Run APT example

`clingo asp/_apt.lp examples/example_apt.lp --opt-mode=optN --quiet=1 --project -c max_extra_encs=0`

This only prints the relevant data and restricts the extra encodings that are being generated.

### Releases

* Make sure everything works!
* Update `__version__` in `draco/` and use the right version below.
* `git commit -m "bump version to 0.0.1"`
* Tag the last commit `git tag -a v0.0.1`.
* `git push` and `git push --tags`
* Run `python sdist upload`.

## Resources

### Related Repositories

Previous prototypes


Related software


### Guides


Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for draco, version 0.0.9
Filename, size File type Python version Upload date Hashes
Filename, size draco-0.0.9.tar.gz (169.2 kB) File type Source Python version None Upload date Hashes View

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring DigiCert DigiCert EV certificate Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page