• Stars
    star
    122
  • Rank 292,031 (Top 6 %)
  • Language
    Python
  • License
    MIT License
  • Created over 3 years ago
  • Updated over 3 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Viewflow is an Airflow-based framework that allows data scientists to create data models without writing Airflow code.

Viewflow

Viewflow is a framework built on the top of Airflow that enables data scientists to create materialized views. It allows data scientists to focus on the logic of the view creation in their preferred tool.

Viewflow automatically creates Airflow DAGs and tasks based on SQL, Python, R or Rmd files. Normally, each of these files is responsible for materializing a new view. You write the view definition, Viewflow handles the rest!

One of the major features of Viewflow is its ability to manage tasks' dependencies, i.e., views used to create another view. Viewflow can automatically extract from the code (e.g. SQL query or Python script) the internal and external dependencies. An internal dependency is a view that belongs to the same DAG as a view being created. An external dependency is a view that belongs to a different DAG. The benefits of automatic dependency management are twofold: First, data scientists don't have to manually list dependencies, usually an error-prone process. Second, it makes sure that no view is built on stale data (because all dependent views will be updated beforehand).

Currently, Viewflow supports SQL, Python, R and Rmd views and PostgreSQL/Redshift as a destination. We will continue improving Viewflow by adding new view types (e.g. Jupyter Notebooks) and destinations (e.g., Snowflake, BigQuery, ...).

Do you want more context on why we built and released Viewflow? Check out our announcement blog post: Data Scientists, don’t worry about data engineering: Viewflow has your back.!

Viewflow demo

We created a demo that shows how Viewflow works. The demo creates multiple DAGs: viewflow-demo-1 through viewflow-demo-4. These DAGs create a total of four views in a local Postgres database. Check out the view files in demo/dags/. Some of the following commands are different based on which Airflow version you're using. For new users, Airflow 2 is the best option. However, you can also run the demo using the older Airflow 1.10 version by using the indicated commands.

Run the demo

We use docker-compose to instantiate an Apache Airflow instance and a Postgres database. The Airflow container and the Postgres container are defined in the docker-compose-airflow<version>.yml files. The first time you want to run the demo, you will first have to build the Apache Airflow docker image that embeds Viewflow:

docker-compose -f docker-compose-airflow2.yml build     # Airflow 2
docker-compose -f docker-compose-airflow1.10.yml build  # Airflow 1.10

Then run the docker containers:

docker-compose -f docker-compose-airflow2.yml up     # Airflow 2
docker-compose -f docker-compose-airflow1.10.yml up  # Airflow 1.10

Go to your local Apache Airflow instance on http://localhost:8080. There are four DAGs called viewflow-demo-1 through viewflow-demo-4. Notice how Viewflow automatically generated these DAGs based on the example queries in the subfolders of demo/dags/!

By default, the DAGs are disabled. Turn the DAGs on by clicking on the button Off. This will trigger the DAGs.

Query the views

Once the DAGs have run and all tasks completed, you can query the views created by Viewflow in the local Postgres database created by Docker. You can use any Postgres client (note that Postgres is running locally on port 5432):

psql -h localhost -p 5432 -U airflow -d airflow

Use airflow when psql asks you for the user password.

There is a schema named viewflow_raw and a schema named viewflow_demo. The first one contains three tables: users, courses, and user_course. They are considered as the raw data. The second schema, viewflow_demo, is the schema in which the views created by Viewflow are stored.

\dn

+---------------+---------+
| Name          | Owner   |
|---------------+---------|
| public        | airflow |
| viewflow_demo | airflow |
| viewflow_raw  | airflow |
+---------------+---------+

Viewflow created four views: user_xp (SQL), user_enriched (SQL), course_enriched (SQL) and top_3_user_xp (Python)

\dt viewflow_demo.

+---------------+-----------------+--------+---------+
| Schema        | Name            | Type   | Owner   |
|---------------+-----------------+--------+---------|
| viewflow_demo | course_enriched | table  | airflow |
| viewflow_demo | top_3_user_xp   | table  | airflow |
| viewflow_demo | user_enriched   | table  | airflow |
| viewflow_demo | user_xp         | table  | airflow |
+---------------+-----------------+--------+---------+

You can query these tables to see their data:

select * from viewflow_demo.user_xp;

+-----------+------+-----------------------+
| user_id   | xp   | __view_generated_at   |
|-----------+------+-----------------------|
| 1         | 750  | 2021-03-17            |
| 2         | 200  | 2021-03-17            |
| 3         | 550  | 2021-03-17            |
| 4         | 500  | 2021-03-17            |
| 5         | 650  | 2021-03-17            |
| 6         | 430  | 2021-03-17            |
| 7         | 300  | 2021-03-17            |
| 8         | 280  | 2021-03-17            |
| 9         | 100  | 2021-03-17            |
| 10        | 350  | 2021-03-17            |
+-----------+------+-----------------------+

You can also access the tables' comment (both table and columns):

select obj_description('viewflow_demo.user_enriched'::regclass) as view_description;

+---------------------------------------------+
| view_description                            |
|---------------------------------------------|
| A table with enriched information of users  |
+---------------------------------------------+
select
   column_name,
   col_description((table_schema||'.'||table_name)::regclass::oid, ordinal_position) as column_comment
 from
   information_schema.columns
 where
   table_schema = 'viewflow_demo'
 and
   table_name = 'user_enriched';

+--------------------------+-----------------------------------------------+
| column_name              | column_comment                                |
|--------------------------+-----------------------------------------------|
| user_id                  | The user id                                   |
| xp                       | The user amount of XP                         |
| last_course_completed_at | When was the last course completed by a user  |
| last_course_completed    | Name of the latest completed course by a user |
| number_courses_completed | Number of completed courses by a user         |
| __view_generated_at      | <null>                                        |
+--------------------------+-----------------------------------------------+

And that's it! Congrats on running the demo 🚀 If you want to play more with Viewflow, follow the installation instructions below.

Installation instructions

✉️ If you have any issue with the installation, configuration, or creation of your DAGs, do not hesitate to contact us!

The current installation process requires you to install Viewflow from the GitHub repository:

RUN pip install git+https://github.com/datacamp/viewflow.git 

Create a new DAG

Viewflow creates the DAGs automatically based on configuration files.

Here are the steps to create a DAG for the first time.

Create the Viewflow main script

In your Airflow DAG directory (usually $AIRFLOW_HOME/dags), create a python script called viewflow-dags.py that contains the following Python code:

from viewflow import create_dags

DAG = create_dags("./dags", globals(), "<views_schema_name>")

This script is executed by Airflow. It calls the main Viewflow function that creates your DAGs. The first parameter is the directory in which your dag folders are located. The third parameter is the schema name in your data warehouse, where your views will be materialized.

Create an Airflow connection to your destination

Viewflow needs to know where to write the views. It uses an Airflow connection that is referred to in the view files by specifying a connection_id. Currently, Viewflow supports Postgres (or Redshift) data warehouses. Please look at the Airflow documentation to create a Postgres connection.

E.g. the demo's connection is managed using environmemt variables declared in demo/.env. This file is the env_file specified in the docker-compose-airflow<version>.yml files and it allows the scheduler and webserver containers to connect to the Postgres server.

Create your DAG directories

In Viewflow, the DAGs are created based on a configuration file and on the SQL and Python files in the same directory.

In $AIRFLOW_HOME/dags/, create a directory called my-first-viewflow-dag. In this directory, create a config.yml file that contains the following yml fields:

default_args:
    owner: <email>
    retries: 1
schedule_interval: 0 6 * * *
start_date: "2021-01-01"

Adapt the values of each element to what suits you. The default_args element contains the Airflow default DAG parameters.

The schedule_interval and start_date elements are the Viewflow counterparts of Airflow's schedule_interval and start_date.

You can now add your SQL and Python files in this directory (see sections below). This will create a new DAG in Airflow called my-first-viewflow-dag that will be triggered every day at 6 AM UTC as of January 1, 2021. All failed tasks will be retried once.

View metadata

Viewflow expects some metadata that must be included in the SQL and Python files (examples follow). Here are the fields that should be included in a yml format:

  • owner: The owner of the view (i.e., who is view responsible). The owner appears in Airflow and allows users to know who they should talk to if they have some questions about the view.
  • description: What is the view about. Viewflow uses this field as a view comment in the database. The description can be retrieved in SQL (see Section Query the views).
  • fields (list): Description of each column of the view. Viewflow uses these fields as column comments in the database. The column descriptions can be retrieved in SQL (see Section Query the views).
  • schema: The name of the schema in which Viewflow creates the view. It's also used by Viewflow to create the dependencies.
  • connection_id: Airflow connection name used to connect to the database (See Section Create an Airflow connection to your destination).

The newly created view has the same name as the filename of the SQL query, Python script or R(md) script.

SQL views

A SQL view is created by a SQL file. This SQL file must contain the SQL query (as a SELECT statement) of your view and the view metadata. Here's an example:

/* 
---
owner: email address of the view owner
description: A description of your view. It's used as the view's description in the database
fields:
  email: Description of your column -- used as the view column's description in the database
schema: schema_name_in_your_destination (e.g. viewflow_demo)
connection_id: airflow_destination_connection
--- 
*/

SELECT DISTINCT email FROM viewflow_raw.users

Python views

Please note that the implementation of the Python view should be considered as beta. It is a newer implementation of the Python view that we use at DataCamp.

A Python view is created based on a Python script. This script must contain at least one function with the view's description metadata in its docstring, which returns a Pandas dataframe.

Here's an example of a Python view:

import pandas as pd

def python_view(db_engine):
    """
    ---
    owner: email address of the view owner
    description: A description of your view. It's used as the view's description in the database
    fields:
        email: Description of your column -- used as the view column's description in the database
    schema: schema_name_in_your_destination (e.g. viewflow_demo)
    connection_id: airflow_destination_connection
    ---
    """
    df = pd.read_sql_table("users", db_engine, schema="viewflow_raw")
    return df[["email"]]

Please note that Viewflow expects the Python function that creates the view to have the parameter db_engine (used to connect to the database). You don't have to set db_engine anywhere. Viewflow takes care of setting this variable.

R views

Viewflow handles R scripts similar to the existing SQL and Python files. Additionally, there's an element of automatisation. You simply define the view in R code, Viewflow will automatically read the necessary tables and write the new view to the database. Note that you need to define the new view in the R script with the same name as the R script (which is also the name of the table where the view is materialized in the database).

By default, other tables are expected to be referenced as <schema_name>.<table_name>. This default behaviour can be changed by adding a new function in dependencies_r_patterns.py and adding a line dependency_function: <your_custom_function> to the metadata of the R script. The script user_xp_duplicate.R illustrates this.

Rmd views

Rmd scripts can be used mostly like R scripts. For Rmd scripts, you do have to explicitly configure the automated reading and writing of tables by adding automate_read_write: True to the metadata. By default, the script is executed as is. The task top_3_user_xp_duplicate.Rmd contains an explanation of the usage of Rmd scripts.

Configuring callbacks

A useful feature is enabling callbacks when a task succeeds, fails, or is retried. This callback can take many forms, e.g. an email or a Slack message. Viewflow allows you to define your own callbacks in viewflow/task_callbacks.py. These callbacks can be configured on multiple levels:

  1. By default, certain functions defined in viewflow/task_callbacks.py are used (e.g. on_success_callback_default).
  2. The callbacks can be overwritten for all tasks in a given DAG. E.g. if you have defined 3 custom callback functions in viewflow/task_callbacks.py, you can specify them in the DAG's config.yml file as following:
default_args:
  on_success_callback: on_success_callback_custom
  on_failure_callback: on_failure_callback_custom
  on_retry_callback: on_retry_callback_custom
  1. For the highest level of configurability, you can overwrite the callbacks for a specific task. This option is prioritized, it doesn't matter whether there are callbacks specified in the DAG's config.yml file. The callback functions can simply be added to the metadata of the task's script:
on_success_callback: on_success_callback_custom
on_failure_callback: on_failure_callback_custom
on_retry_callback: on_retry_callback_custom

Of course, options 1, 2 and 3 can be combined to efficiently configure the callbacks of a multitude of tasks.

Contributing to Viewflow

We welcome all sorts of contributions, be it new features, bug fixes or documentation, we encourage you to create a new PR. To create a new PR or to report new bugs, please read how to contribute to Viewflow.

In the remainder of this section, we show you how to prepare your environment to contribute to Viewflow.

Install Poetry

See https://python-poetry.org/docs/#osx-linux-bashonwindows-install-instructions for comprehensive documentation.

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python

Install the dependencies

You can automatically install the required dependencies by running

poetry install

By default, this will install Airflow 2 and its corresponding dependencies. If you want to use Airflow 1.10, copy the [email protected]/pyproject.toml file to the main directory.

Prepare your environment to run the tests

Postgres

Use docker compose to set up a PostgreSQL database locally:

docker-compose -f docker-compose-test.yml up

If you get a message saying that port 5432 is in use, it means you have a different PostgreSQL server running on your machine. If you used homebrew to install it, you could use brew services stop postgresql to stop the other server.

Import the fixtures into the local database (the password is passw0rd):

psql -U user -W -h localhost -f tests/fixtures/load_postgres.sql -d viewflow

Run Pytest

Before you can continue, you will need to set up an Airflow SQLite database.

poetry run airflow db init  # Airflow 2
poetry run airflow initdb   # Airflow 1.10

If running into problems, this link can be helpful. In particular, it's possible you get a Symbol not found: _Py_GetArgcArgv error. This is easily fixed by creating a Python virtual environment as demonstrated in the link, activating this virtual environment and then running poetry install again.

Note for Airflow 1.10.12: if you get an ImportError, it can be helpful to refer to this post.

After setting up the database, run

poetry run pytest

In case the database connection is set up incorrectly, run

poetry run airflow db reset  # Airflow 2
poetry run airflow resetdb   # Airflow 1.10

Viewflow architecture

We built Viewflow around three main components: the parser, the adapter, and the dependency extractor.

The parser transforms a source file (e.g., SQL, Rmd, Python) that contains the view's metadata (e.g., view's owner, view's descriptions, and column's descriptions) and the view's code into a specific Viewflow data structure. The data structure is used by the other components in the Viewflow architecture: the adapter and the dependency creator.

The adapter is the translation layer of Viewflow's views to their corresponding Airflow counterpart. It uses the data structure objects created by the parser to create an Airflow task object (i.e., an Airflow operator).

Finally, the dependency extractor uses the parser's data structure objects to set the internal and external dependencies to the Airflow task object created by the adapter.

This architecture allows us to add new source file types in the future easily (e.g. Python notebook).

Acknowledgments

Today's version of Viewflow is the result of a joint effort of ex and current DataCampers. We would like to thank in particular the following persons who significantly contributed to Viewflow:

More Repositories

1

datacamp-light

Convert any blog or website to an interactive learning platform for data science
TypeScript
1,235
star
2

datacamp-community-tutorials

Tutorials for DataCamp (www.datacamp.com)
Jupyter Notebook
965
star
3

course-resources-ml-with-experts-budgets

Further student resources for DrivenData's 'Machine Learning with the Experts: School Budgets' DataCamp course.
Jupyter Notebook
559
star
4

courses-introduction-to-python

Introduction to Python by Filip Schouwenaars
Shell
367
star
5

rdocumentation-2.0

📚 RDocumentation provides an easy way to search the documentation for every version of every R package on CRAN and Bioconductor.
TypeScript
283
star
6

RDocumentation

R package to integrate rdocumentation.org into your R workflow
R
212
star
7

COVID-19-EDA-tutorial

This tutorial's purpose is to introduce people to the [2019 Novel Coronavirus COVID-19 (2019-nCoV) Data Repository by Johns Hopkins CSSE](https://github.com/CSSEGISandData/COVID-19) and how to explore it using some foundational packages in the Scientific Python Data Science stack.
Jupyter Notebook
159
star
8

funneljoin

Join tables based on events occurring in sequence in a funnel.
R
140
star
9

shinybones

A highly opinionated framework for building shiny dashboards.
R
136
star
10

courses-introduction-to-r

Introduction to R by Jonathan Cornelissen
R
132
star
11

datacamp_facebook_live_nlp

DataCamp Facebook Live Code Along Session 1: Enjoy.
Jupyter Notebook
126
star
12

courses-intermediate-sql-queries

Intermediate SQL Queries by Nick Carchedi
Python
124
star
13

careerhub-data

Certification Data
103
star
14

tutorial

R Package to convert R Markdown files to DataCamp Light HTML files
R
82
star
15

pythonwhat

Verify Python code submissions and auto-generate meaningful feedback messages.
Python
61
star
16

datacamp_facebook_live_titanic

DataCamp Facebook Live Code Along Session 2: Learn how to complete a Kaggle competition using exploratory data analysis, data munging, data cleaning and machine leaning. Enjoy.
Jupyter Notebook
61
star
17

courses-introduction-to-version-control-with-git

Introduction to Version Control with Git by DataCamp
Shell
57
star
18

misc-courses-HarvardX-IDS-Mod-1

R
46
star
19

tidymetrics

Dimensional modeling done the tidy way!
R
45
star
20

rdocumentation-app

The web application running rdocumentation.org.
JavaScript
44
star
21

courses-introduction-to-shell

Introduction to Shell by Greg Wilson
Shell
44
star
22

datacamp_facebook_live_ny_resolution

In this Facebook live code along session with Hugo Bowne-Anderson, you're going to check out Google trends data of keywords 'diet', 'gym' and 'finance' to see how they vary over time.
Jupyter Notebook
44
star
23

Market-Basket-Analysis-in-python-live-training

Live Training: Market Basket Analysis in Python
Jupyter Notebook
42
star
24

antlr-ast

Library for building abstract syntax trees from antlr parsers
Python
39
star
25

datacamp_facebook_live_intro_to_tidyverse

DataCamp Facebook Live Code Along Session 5: Learn how to to use tidy tools in R, such as dplyr and ggplot2, to intuitively explore & analyze your data.
38
star
26

testwhat

Write Submission Correctness Tests for R exercises
R
33
star
27

ast-viewer

app to visualize antlr parse tree ast
Vue
26
star
28

community-courses-kaggle-python-tutorial-on-machine-learning

Kaggle Python Tutorial on Machine Learning by Weston Stearns [OPEN]
Shell
26
star
29

datacamp_facebook_live_dataframed

DataCamp Facebook Live Code Along Session 4: Learn techniques that guests on the DataFramed podcast say are their favourite. Enjoy!
Jupyter Notebook
24
star
30

design-system

The DataCamp Design System, aka Waffles
TypeScript
21
star
31

jsconfig

All the dotfiles for javascript @ DataCamp
JavaScript
20
star
32

courses-intro-to-r-beta

Reworked introduction to R course hosted on DataCamp
R
20
star
33

community-groupby

This repository contains notebook + code for DataCamp community post on groupbys, split-apply-combine and pandas.
Jupyter Notebook
19
star
34

datacamp-light-wordpress

A WordPress Plugin that allows easy integration of the DataCamp Light interactive learning widget into posts and pages.
PHP
18
star
35

antlr-plsql

ANTLR
17
star
36

data-cleaning-with-pyspark-live-training

Live Training Session: Cleaning Data with Pyspark
Jupyter Notebook
14
star
37

Machine-Learning-With-XGboost-live-training

Live Training Session: Machine Learning with XGboost
Jupyter Notebook
14
star
38

awesome

A list of tools and resources we love
14
star
39

machine-learning-with-scikit-learn-live-training

Live Training Session: Machine Learning with Scikit Learn
Jupyter Notebook
13
star
40

waffles

Waffles is the DataCamp design system.
TypeScript
13
star
41

Hacker-Stats-in-Python-Live-Training

Live Training Session: Hacker Stats in Python
Jupyter Notebook
12
star
42

universal-rx-request

Library to do HTTP requests with RxJS
JavaScript
11
star
43

codemirror-6-getting-started

Getting started with CodeMirror 6, the popular code editor library
JavaScript
10
star
44

shinymetrics

Shiny modules for visualizing tidy metrics
R
10
star
45

community-courses-tidy-data-in-python-mini-course

Tidy Data in Python Mini-Course by Vincent Lan [OPEN]
Jupyter Notebook
9
star
46

data-analysis-in-sql-live-training

Live Training Session: Data Analysis in SQL
Jupyter Notebook
9
star
47

Applied-Machine-Learning-Ensemble-Modeling-live-training

Live Training Session: Applied Machine Learning:Ensemble Modeling
Jupyter Notebook
9
star
48

time-series-analysis-in-python-live-training

Live Training Session: Time Series Analysis in Python
Jupyter Notebook
8
star
49

projects-introduction-to-datacamp-projects-python-guided

Introduction to DataCamp Projects by Rasmus Bååth
Jupyter Notebook
8
star
50

authoring

CSS
8
star
51

datacamp-metoo-analysis

What can data science tell us about tweets with the #MeToo hashtag? This repository contains the code for the analysis
Jupyter Notebook
8
star
52

antlr-tsql

ANTLR
7
star
53

dbconnect-python

Easily connect to all internal databases. Only for internal use.
Python
7
star
54

community-hierarchical-indices

This repository contains notebook + code for DataCamp community post on hierarchical indices, groupby, split-apply-combine and pandas.
Jupyter Notebook
6
star
55

ggdc

Datacamp Themes for ggplot2.
R
6
star
56

dbconnectr

Fetch credentials on the fly as you connect to databases
R
6
star
57

working-with-text-data-in-python-live-training

Live Training Session: Working with Text Data in Python
Jupyter Notebook
6
star
58

community-courses-introduction-to-probability-and-data-labs

Introduction to Probability and Data - Labs by Mine Çetinkaya-Rundel [OPEN]
HTML
6
star
59

community-courses-education-data-analysis-primer-r-dplyr-and-plotly

Education Data Analysis Prime: R, dplyr, and Plotly by Jake Moody [OPEN]
R
6
star
60

react-native-survicate

React Native bindings for the Survicate SDK
Java
6
star
61

datacamp-thanksgiving-spending

How much money does America spend in the holiday season? Let's delve into the data to find out.
Jupyter Notebook
5
star
62

python-live-training-template

Jupyter Notebook
5
star
63

sheetwhat

Verify Spreadsheets and auto-generate meaningful feedback messages.
Python
4
star
64

community-courses-r-for-the-intimidated

R for the Intimidated by Annika Salzberg [OPEN]
4
star
65

community-courses-exploring-polling-data-in-r

Exploring Polling Data in R by Matt Isaacs [OPEN]
R
4
star
66

Visualizing-Big-Data-in-R-live-training

Live Training Session: Visualizing Big Data in R
Jupyter Notebook
4
star
67

community-courses-dataframe-manipulation-r-chinese

Dataframe Manipulation in R by Yao-Jen Kuo [OPEN]
R
3
star
68

sqlwhat

Python
3
star
69

Brand-Analysis-using-Social-Media-Data-in-R-Live-Training

Live Training Session: Brand Analysis using Social Media Data in R
Jupyter Notebook
3
star
70

base-plugin

JS boilerplate to create plugins
JavaScript
3
star
71

community-courses-introduction-to-r-chinese

Introduction to R (Chinese) by Jonathan Cornelissen/Translated by Yao-Jen Kuo [OPEN]
R
3
star
72

data-processing-in-shell-live-training

Jupyter Notebook
3
star
73

projects-introduction-to-datacamp-projects-r-guided

Introduction to DataCamp Projects by Rasmus Bååth
Jupyter Notebook
3
star
74

community-hurricane-visualizations

This repository contains notebook + code used to generate the figures in my DataCamp article 'How not to plot hurricane predictions'
Jupyter Notebook
3
star
75

protobackend

Python
3
star
76

IRkernel.testthat

R
3
star
77

projects-instructor-application-python

The application process for becoming a project instructor
Jupyter Notebook
3
star
78

workspace-codealong-afors

Explore US Air Force personnel data
Jupyter Notebook
3
star
79

asana

An R package for accessing the Asana API
R
3
star
80

shellwhat

Python
2
star
81

protowhat

Python
2
star
82

community-courses-reading-data-into-r-with-readr

Reading Data into R with readr by Hadley Wichkam [OPEN]
R
2
star
83

sme-dle-case-study-application

The audition portion of the application process for becoming a subject matter expert (SME) for Data Literacy and Essentials (DLE).
2
star
84

ipython_nose

Python
2
star
85

community-courses-introduction-to-r-french

Introduction to R (French) by Jonathan Cornelissen/Translated by Vincent Guyader [OPEN]
R
2
star
86

shell-notebook-sandbox

Jupyter Notebook
2
star
87

Visualizing-Big-Data-in-R-live-training2

DataCamp live training on visualizing big data in R
Jupyter Notebook
2
star
88

community-courses-r-yelp-and-the-search-for-good-indian-food

R, Yelp and the search for good Indian food by Weston Stearns [OPEN]
R
2
star
89

community-courses-introduction-to-r-portuguese

Introduction to R (Portugese) by Jonathan Cornelissen/Translated by Paulo Vasconcellos [OPEN]
R
2
star
90

catsim

Python
2
star
91

r-live-training-template

Jupyter Notebook
2
star
92

string-manipulation-in-sql-live-training

Live Training Session: String Manipulation with SQL
Jupyter Notebook
2
star
93

bash_kernel

Python
2
star
94

finddatasetpkgs

An R package that lists all CRAN R packages with "datasets" or "data sets" in the Title field of their DESCRIPTION file.
R
1
star
95

Creating-Dashboards-in-Shiny-R-live-training

Live Training Session: Creating Dashboards with Shiny R
Jupyter Notebook
1
star
96

Visualizing-Big-Data-in-R-live-training3

DataCamp live training on visualizing big data in R
Jupyter Notebook
1
star
97

Visualizing-Big-Data-in-R-live-training4

DataCamp live training on visualizing big data in R
Jupyter Notebook
1
star
98

setting-up-your-environment-in-r-live-training

Live Training Session: Setting Up Your Environment in R
Jupyter Notebook
1
star
99

workspace-tutorial-python-linear-regression

Notebook for a video tutorial on modeling in Python, focussed on linear regression.
Jupyter Notebook
1
star
100

shell-live-training-template

Jupyter Notebook
1
star