def project_check_config(directory):
"""Check a config for validity and help with migrations."""
cli_message("Checking your config files for validity...\n")
try:
is_config_ok, error_message = do_config_check(directory)
if is_config_ok:
cli_message("<green>Your config file appears valid!</green>")
else:
cli_message("Unfortunately, your config appears to be invalid:\n")
cli_message("<red>{}</red>".format(error_message))
sys.exit(1)
except ge_exceptions.ZeroDotSevenConfigVersionError as err:
_offer_to_install_new_template(err, directory)
def suite_new(suite, directory, view, batch_kwargs):
"""
Create a new expectation suite.
Great Expectations will choose a couple of columns and generate expectations about them
to demonstrate some examples of assertions you can make about your data.
"""
try:
context = DataContext(directory)
except ge_exceptions.ConfigNotFoundError as err:
cli_message("<red>{}</red>".format(err.message))
return
except ge_exceptions.ZeroDotSevenConfigVersionError as err:
_offer_to_install_new_template(err, context.root_directory)
return
if batch_kwargs is not None:
batch_kwargs = json.loads(batch_kwargs)
datasource_name = None
generator_name = None
generator_asset = None
try:
success, suite_name = create_expectation_suite_impl(
context,
datasource_name=datasource_name,
generator_name=generator_name,
generator_asset=generator_asset,
batch_kwargs=batch_kwargs,
expectation_suite_name=suite,
additional_batch_kwargs={"limit": 1000},
show_intro_message=False,
open_docs=view,
)
if success:
cli_message(
"A new Expectation suite '{}' was added to your project".format(
suite_name
)
)
except (
ge_exceptions.DataContextError,
ge_exceptions.ProfilerError,
IOError,
SQLAlchemyError,
) as e:
cli_message("<red>{}</red>".format(e))
sys.exit(1)
def docs_build(directory, site_name, view=True):
"""Build Data Docs for a project."""
try:
context = DataContext(directory)
build_docs(context, site_name=site_name, view=view)
except ge_exceptions.ConfigNotFoundError as err:
cli_message("<red>{}</red>".format(err.message))
sys.exit(1)
except ge_exceptions.ZeroDotSevenConfigVersionError as err:
_offer_to_install_new_template(err, context.root_directory)
return
except ge_exceptions.PluginModuleNotFoundError as err:
cli_message(err.cli_colored_message)
sys.exit(1)
except ge_exceptions.PluginClassNotFoundError as err:
cli_message(err.cli_colored_message)
sys.exit(1)
def suite_list(directory):
"""Lists available expectation suites."""
try:
context = DataContext(directory)
except ge_exceptions.ConfigNotFoundError as err:
cli_message("<red>{}</red>".format(err.message))
return
except ge_exceptions.ZeroDotSevenConfigVersionError as err:
_offer_to_install_new_template(err, context.root_directory)
return
suite_names = context.list_expectation_suite_names()
if len(suite_names) == 0:
cli_message("No expectation suites available")
return
if len(suite_names) == 1:
cli_message("1 expectation suite available:")
if len(suite_names) > 1:
cli_message("{} expectation suites available:".format(len(suite_names)))
for name in suite_names:
cli_message("\t{}".format(name))
def suite_edit(suite, datasource, directory, jupyter, batch_kwargs):
"""
Generate a Jupyter notebook for editing an existing expectation suite.
The SUITE argument is required. This is the name you gave to the suite
when you created it.
A batch of data is required to edit the suite, which is used as a sample.
The edit command will help you specify a batch interactively. Or you can
specify them manually by providing --batch-kwargs in valid JSON format.
Read more about specifying batches of data in the documentation: https://docs.greatexpectations.io/
"""
try:
context = DataContext(directory)
except ge_exceptions.ConfigNotFoundError as err:
cli_message("<red>{}</red>".format(err.message))
return
except ge_exceptions.ZeroDotSevenConfigVersionError as err:
_offer_to_install_new_template(err, context.root_directory)
return
suite = _load_suite(context, suite)
if batch_kwargs:
try:
batch_kwargs = json.loads(batch_kwargs)
if datasource:
batch_kwargs["datasource"] = datasource
_batch = context.get_batch(batch_kwargs, suite.expectation_suite_name)
assert isinstance(_batch, DataAsset)
except json_parse_exception as je:
cli_message("<red>Please check that your batch_kwargs are valid JSON.\n{}</red>".format(je))
sys.exit(1)
except ge_exceptions.DataContextError:
cli_message("<red>Please check that your batch_kwargs are able to load a batch.</red>")
sys.exit(1)
except ValueError as ve:
cli_message("<red>Please check that your batch_kwargs are able to load a batch.\n{}</red>".format(ve))
sys.exit(1)
else:
cli_message("""
A batch of data is required to edit the suite - let's help you to specify it."""
)
additional_batch_kwargs = None
try:
data_source = select_datasource(context, datasource_name=datasource)
except ValueError as ve:
cli_message("<red>{}</red>".format(ve))
sys.exit(1)
if not data_source:
cli_message("<red>No datasources found in the context.</red>")
sys.exit(1)
if batch_kwargs is None:
datasource_name, batch_kwarg_generator, data_asset, batch_kwargs = get_batch_kwargs(
context,
datasource_name=data_source.name,
generator_name=None,
generator_asset=None,
additional_batch_kwargs=additional_batch_kwargs
)
notebook_name = "{}.ipynb".format(suite.expectation_suite_name)
notebook_path = os.path.join(context.root_directory, context.GE_EDIT_NOTEBOOK_DIR, notebook_name)
NotebookRenderer().render_to_disk(suite, batch_kwargs, notebook_path)
cli_message(
"To continue editing this suite, run <green>jupyter notebook {}</green>".format(
notebook_path
)
)
if jupyter:
subprocess.call(["jupyter", "notebook", notebook_path])
