With yaml_write() we can take different pointblank objects (these are the ptblank_agent, ptblank_informant, and tbl_store) and write them to YAML. With an agent, for example, yaml_write() will write that everything that is needed to specify an agent and it's validation plan to a YAML file. With YAML, we can modify the YAML markup if so desired, or, use as is to create a new agent with the yaml_read_agent() function. That agent will have a validation plan and is ready to interrogate() the data. We can go a step further and perform an interrogation directly from the YAML file with the yaml_agent_interrogate() function. That returns an agent with intel (having already interrogated the target data table). An informant object can also be written to YAML with yaml_write().

One requirement for writing an agent or an informant to YAML is that we need to have a table-prep formula (read_fn) specified (it's an R formula that is used to read the target table when interrogate() or incorporate() is called). This option can be set when using create_agent()/create_informant() or with set_read_fn() (useful with an existing agent or informant object).

yaml_write(
...,
.list = list2(...),
filename = NULL,
path = NULL,
expanded = FALSE,
quiet = FALSE
)

## Arguments

... Any mix of pointblank objects such as the agent (ptblank_agent), the informant (ptblank_informant), or the table store (tbl_store). The agent and informant can be combined into a single YAML file (so as both objects have the same value for read_fn). A table store cannot be combined with either an agent or an informant so it must undergo conversion alone. Allows for the use of a list as an input alternative to .... The name of the YAML file to create on disk. It is recommended that either the .yaml or .yml extension be used for this file. If not provided then default names will be used ("tbl_store.yml") for a table store and the other objects will get default naming to the effect of "

## Value

Invisibly returns TRUE if the YAML file has been written.

## Function ID

11-1

Other pointblank YAML: yaml_agent_interrogate(), yaml_agent_show_exprs(), yaml_agent_string(), yaml_exec(), yaml_informant_incorporate(), yaml_read_agent(), yaml_read_informant()

## Examples

if (interactive()) {

# Let's go through the process of
# developing an agent with a validation
# plan (to be used for the data quality
# analysis of the small_table dataset),
# plan to a pointblank YAML file

# Creating an action_levels object is a
# common workflow step when creating a
# pointblank agent; we designate failure
# thresholds to the warn, stop, and
# notify states using action_levels()
al <-
action_levels(
warn_at = 0.10,
stop_at = 0.25,
notify_at = 0.35
)

# Now create a pointblank agent object
# and give it the al object (which
# serves as a default for all validation
# steps which can be overridden); the
# data will be referenced in a read_fn
# (a requirement for writing to YAML)
agent <-
create_agent(
label = "A simple example with the small_table.",
actions = al
)

# Then, as with any agent object, we
# can add steps to the validation plan by
# using as many validation functions as we
# want
agent <-
agent %>%
col_exists(vars(date, date_time)) %>%
col_vals_regex(
vars(b), regex = "[0-9]-[a-z]{3}-[0-9]{3}"
) %>%
rows_distinct() %>%
col_vals_gt(vars(d), value = 100) %>%
col_vals_lte(vars(c), value = 5)

# The agent can be written to a pointblank
# YAML file with yaml_write()
yaml_write(
agent,
filename = "agent-small_table.yml"
)

# The 'agent-small_table.yml' file is
# available in the package through
# system.file()
yml_file <-
system.file(
"yaml", "agent-small_table.yml",
package = "pointblank"
)

# We can view the YAML file in the console
# with the yaml_agent_string() function
yaml_agent_string(filename = yml_file)

# The YAML can also be printed in the console
# by supplying the agent as the input
yaml_agent_string(agent = agent)

# At a later time, the YAML file can
# be read into a new agent with the
# yaml_read_agent() function
agent <-

class(agent)

# We can interrogate the data (which
# is accessible through the read_fn)
# with interrogate() and get an
# agent with intel, or, we can
# interrogate directly from the YAML
# file with yaml_agent_interrogate()
agent <-
yaml_agent_interrogate(filename = yml_file)

class(agent)

}

`