Search is not available for this dataset
identifier stringlengths 1 155 | parameters stringlengths 2 6.09k | docstring stringlengths 11 63.4k | docstring_summary stringlengths 0 63.4k | function stringlengths 29 99.8k | function_tokens list | start_point list | end_point list | language stringclasses 1
value | docstring_language stringlengths 2 7 | docstring_language_predictions stringlengths 18 23 | is_langid_reliable stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
ACMapping.__init__ | (self, rkey: str, location: str, *,
name: str,
kind: str="Mapping",
apiVersion: Optional[str]=None,
serialization: Optional[str]=None,
service: str,
prefix: str,
prefix_regex: bool=False,
... |
Initialize an ACMapping from the raw fields of its ACResource.
|
Initialize an ACMapping from the raw fields of its ACResource.
| def __init__(self, rkey: str, location: str, *,
name: str,
kind: str="Mapping",
apiVersion: Optional[str]=None,
serialization: Optional[str]=None,
service: str,
prefix: str,
prefix_regex: bool=False,
... | [
"def",
"__init__",
"(",
"self",
",",
"rkey",
":",
"str",
",",
"location",
":",
"str",
",",
"*",
",",
"name",
":",
"str",
",",
"kind",
":",
"str",
"=",
"\"Mapping\"",
",",
"apiVersion",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"serializat... | [
45,
4
] | [
87,
34
] | python | en | ['en', 'error', 'th'] | False |
split_command | (cmd, posix=None) |
- cmd is string list -> nothing to do
- cmd is string -> split it using shlex
:param cmd: string ('ls -l') or list of strings (['ls','-l'])
:rtype: string list
|
- cmd is string list -> nothing to do
- cmd is string -> split it using shlex
:param cmd: string ('ls -l') or list of strings (['ls','-l'])
:rtype: string list
| def split_command(cmd, posix=None):
'''
- cmd is string list -> nothing to do
- cmd is string -> split it using shlex
:param cmd: string ('ls -l') or list of strings (['ls','-l'])
:rtype: string list
'''
if not isinstance(cmd, string_types):
# cmd is string list
pass
el... | [
"def",
"split_command",
"(",
"cmd",
",",
"posix",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"cmd",
",",
"string_types",
")",
":",
"# cmd is string list",
"pass",
"else",
":",
"if",
"not",
"PY3",
":",
"# cmd is string",
"# The shlex module currentl... | [
17,
0
] | [
42,
14
] | python | en | ['en', 'error', 'th'] | False |
LocationManager.push_reset | (self) |
Like push, but simply resets ocount keeping the current filename. Useful
for changing resource types.
|
Like push, but simply resets ocount keeping the current filename. Useful
for changing resource types.
| def push_reset(self) -> ContextManager[Location]:
"""
Like push, but simply resets ocount keeping the current filename. Useful
for changing resource types.
"""
return self.push(filename=self.current.filename) | [
"def",
"push_reset",
"(",
"self",
")",
"->",
"ContextManager",
"[",
"Location",
"]",
":",
"return",
"self",
".",
"push",
"(",
"filename",
"=",
"self",
".",
"current",
".",
"filename",
")"
] | [
49,
4
] | [
54,
56
] | python | en | ['en', 'error', 'th'] | False |
LocationManager.mark_annotated | (self) |
Keeps the current stack, adding an annotation flag to the end of the
filename.
|
Keeps the current stack, adding an annotation flag to the end of the
filename.
| def mark_annotated(self) -> ContextManager[Location]:
"""
Keeps the current stack, adding an annotation flag to the end of the
filename.
"""
previous_filename = self.current.filename
if self.current.filename and not self.current.filename.endswith(':annotation'):
... | [
"def",
"mark_annotated",
"(",
"self",
")",
"->",
"ContextManager",
"[",
"Location",
"]",
":",
"previous_filename",
"=",
"self",
".",
"current",
".",
"filename",
"if",
"self",
".",
"current",
".",
"filename",
"and",
"not",
"self",
".",
"current",
".",
"file... | [
61,
4
] | [
75,
24
] | python | en | ['en', 'error', 'th'] | False |
init | (ctx, usage_stats) |
Initialize a new Great Expectations project.
This guided input walks the user through setting up a new project and also
onboards a new developer in an existing project.
It scaffolds directories, sets up notebooks, creates a project file, and
appends to a `.gitignore` file.
|
Initialize a new Great Expectations project. | def init(ctx, usage_stats):
"""
Initialize a new Great Expectations project.
This guided input walks the user through setting up a new project and also
onboards a new developer in an existing project.
It scaffolds directories, sets up notebooks, creates a project file, and
appends to a `.gitig... | [
"def",
"init",
"(",
"ctx",
",",
"usage_stats",
")",
":",
"directory",
"=",
"toolkit",
".",
"parse_cli_config_file_location",
"(",
"config_file_location",
"=",
"ctx",
".",
"obj",
".",
"config_file_location",
")",
".",
"get",
"(",
"\"directory\"",
")",
"if",
"di... | [
41,
0
] | [
113,
15
] | python | en | ['en', 'error', 'th'] | False |
TemporalModelBase.receptive_field | (self) |
Return the total receptive field of this model as # of frames.
|
Return the total receptive field of this model as # of frames.
| def receptive_field(self):
"""
Return the total receptive field of this model as # of frames.
"""
frames = 0
for f in self.pad:
frames += f
self.frames= frames
return 1 + 2 * frames | [
"def",
"receptive_field",
"(",
"self",
")",
":",
"frames",
"=",
"0",
"for",
"f",
"in",
"self",
".",
"pad",
":",
"frames",
"+=",
"f",
"self",
".",
"frames",
"=",
"frames",
"return",
"1",
"+",
"2",
"*",
"frames"
] | [
46,
4
] | [
54,
29
] | python | en | ['en', 'error', 'th'] | False |
TemporalModelBase.total_causal_shift | (self) |
Return the asymmetric offset for sequence padding.
The returned value is typically 0 if causal convolutions are disabled,
otherwise it is half the receptive field.
|
Return the asymmetric offset for sequence padding.
The returned value is typically 0 if causal convolutions are disabled,
otherwise it is half the receptive field.
| def total_causal_shift(self):
"""
Return the asymmetric offset for sequence padding.
The returned value is typically 0 if causal convolutions are disabled,
otherwise it is half the receptive field.
"""
frames = self.causal_shift[0]
next_dilation = self.filter_widt... | [
"def",
"total_causal_shift",
"(",
"self",
")",
":",
"frames",
"=",
"self",
".",
"causal_shift",
"[",
"0",
"]",
"next_dilation",
"=",
"self",
".",
"filter_widths",
"[",
"0",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"self",
".",
"filt... | [
56,
4
] | [
67,
21
] | python | en | ['en', 'error', 'th'] | False |
TemporalModelBase._get_next_seq | (self, inc, channels, out_seq) |
Generate input information of the next layer
:param inc: input sequence of each group, type:list e.g [455, 569]
:param channels: output channel size of the whole layer, type:int e.g 1024
:param out_seq: output sequence index of each each group, which decides how to group with those inde... |
Generate input information of the next layer
:param inc: input sequence of each group, type:list e.g [455, 569]
:param channels: output channel size of the whole layer, type:int e.g 1024
:param out_seq: output sequence index of each each group, which decides how to group with those inde... | def _get_next_seq(self, inc, channels, out_seq):
"""
Generate input information of the next layer
:param inc: input sequence of each group, type:list e.g [455, 569]
:param channels: output channel size of the whole layer, type:int e.g 1024
:param out_seq: output sequence index of... | [
"def",
"_get_next_seq",
"(",
"self",
",",
"inc",
",",
"channels",
",",
"out_seq",
")",
":",
"in_ch_sum",
"=",
"0",
"for",
"index",
",",
"i",
"in",
"enumerate",
"(",
"out_seq",
")",
":",
"in_ch_sum",
"+=",
"sum",
"(",
"map",
"(",
"lambda",
"x",
":",
... | [
69,
4
] | [
92,
32
] | python | en | ['en', 'error', 'th'] | False |
TemporalModelBase._get_all_seq | (self, inc, channels, out_seq, filter_widths) |
:return: Get all sequence info. for a model.
|
:return: Get all sequence info. for a model.
| def _get_all_seq(self, inc, channels, out_seq, filter_widths):
"""
:return: Get all sequence info. for a model.
"""
in_out_seq = []
in_out_seq.append(self._get_next_seq(inc, channels, out_seq))
# Generate input sequence and output sequence of each layer
for i in r... | [
"def",
"_get_all_seq",
"(",
"self",
",",
"inc",
",",
"channels",
",",
"out_seq",
",",
"filter_widths",
")",
":",
"in_out_seq",
"=",
"[",
"]",
"in_out_seq",
".",
"append",
"(",
"self",
".",
"_get_next_seq",
"(",
"inc",
",",
"channels",
",",
"out_seq",
")"... | [
94,
4
] | [
106,
25
] | python | en | ['en', 'error', 'th'] | False |
TemporalModel.__init__ | (self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024, dense=False) |
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of input features for each joint (typically 2 for 2D input)
num_joints_out -- number of output joints (can be different than input)
filter_widths -- l... |
Initialize this model. | def __init__(self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024, dense=False):
"""
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of ... | [
"def",
"__init__",
"(",
"self",
",",
"num_joints_in",
",",
"in_features",
",",
"num_joints_out",
",",
"filter_widths",
",",
"causal",
"=",
"False",
",",
"dropout",
"=",
"0.25",
",",
"channels",
"=",
"1024",
",",
"dense",
"=",
"False",
")",
":",
"super",
... | [
138,
4
] | [
191,
49
] | python | en | ['en', 'error', 'th'] | False |
Same_Model.__init__ | (self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024, dense=False) |
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of input features for each joint (typically 2 for 2D input)
num_joints_out -- number of output joints (can be different than input)
filter_widths -- l... |
Initialize this model. | def __init__(self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024, dense=False):
"""
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of ... | [
"def",
"__init__",
"(",
"self",
",",
"num_joints_in",
",",
"in_features",
",",
"num_joints_out",
",",
"filter_widths",
",",
"causal",
"=",
"False",
",",
"dropout",
"=",
"0.25",
",",
"channels",
"=",
"1024",
",",
"dense",
"=",
"False",
")",
":",
"super",
... | [
211,
4
] | [
268,
49
] | python | en | ['en', 'error', 'th'] | False |
TemporalModelOptimized1f.__init__ | (self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024) |
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of input features for each joint (typically 2 for 2D input)
num_joints_out -- number of output joints (can be different than input)
filter_widths -- l... |
Initialize this model. | def __init__(self, num_joints_in, in_features, num_joints_out,
filter_widths, causal=False, dropout=0.25, channels=1024):
"""
Initialize this model.
Arguments:
num_joints_in -- number of input joints (e.g. 17 for Human3.6M)
in_features -- number of input feature... | [
"def",
"__init__",
"(",
"self",
",",
"num_joints_in",
",",
"in_features",
",",
"num_joints_out",
",",
"filter_widths",
",",
"causal",
"=",
"False",
",",
"dropout",
"=",
"0.25",
",",
"channels",
"=",
"1024",
")",
":",
"super",
"(",
")",
".",
"__init__",
"... | [
295,
4
] | [
339,
49
] | python | en | ['en', 'error', 'th'] | False |
test_database_evaluation_parameter_store_store_backend_id | (in_memory_param_store) |
What does this test and why?
A Store should be able to report it's store_backend_id
which is set when the StoreBackend is instantiated.
|
What does this test and why?
A Store should be able to report it's store_backend_id
which is set when the StoreBackend is instantiated.
| def test_database_evaluation_parameter_store_store_backend_id(in_memory_param_store):
"""
What does this test and why?
A Store should be able to report it's store_backend_id
which is set when the StoreBackend is instantiated.
"""
# Check that store_backend_id exists can be read
assert in_mem... | [
"def",
"test_database_evaluation_parameter_store_store_backend_id",
"(",
"in_memory_param_store",
")",
":",
"# Check that store_backend_id exists can be read",
"assert",
"in_memory_param_store",
".",
"store_backend_id",
"is",
"not",
"None",
"# Check that store_backend_id is a valid UUID"... | [
186,
0
] | [
195,
76
] | python | en | ['en', 'error', 'th'] | False |
parse_feature_annotation | (docstring: Union[str, List[str], None]) | Parse a docstring and return a feature annotation. | Parse a docstring and return a feature annotation. | def parse_feature_annotation(docstring: Union[str, List[str], None]):
"""Parse a docstring and return a feature annotation."""
list_of_annotations = []
id_val = ""
if docstring is None:
return
if isinstance(docstring, str):
for matches in re.findall(annotation_regex_compiled, docstri... | [
"def",
"parse_feature_annotation",
"(",
"docstring",
":",
"Union",
"[",
"str",
",",
"List",
"[",
"str",
"]",
",",
"None",
"]",
")",
":",
"list_of_annotations",
"=",
"[",
"]",
"id_val",
"=",
"\"\"",
"if",
"docstring",
"is",
"None",
":",
"return",
"if",
... | [
42,
0
] | [
81,
30
] | python | en | ['en', 'en', 'en'] | True |
open_unix_socket | (filename) | Opens a connection to the specified
`Unix domain socket <https://en.wikipedia.org/wiki/Unix_domain_socket>`__.
You must have read/write permission on the specified file to connect.
Args:
filename (str or bytes): The filename to open the connection to.
Returns:
SocketStream: a :class:`~tri... | Opens a connection to the specified
`Unix domain socket <https://en.wikipedia.org/wiki/Unix_domain_socket>`__. | async def open_unix_socket(filename):
"""Opens a connection to the specified
`Unix domain socket <https://en.wikipedia.org/wiki/Unix_domain_socket>`__.
You must have read/write permission on the specified file to connect.
Args:
filename (str or bytes): The filename to open the connection to.
... | [
"async",
"def",
"open_unix_socket",
"(",
"filename",
")",
":",
"if",
"not",
"has_unix",
":",
"raise",
"RuntimeError",
"(",
"\"Unix sockets are not supported on this platform\"",
")",
"# much more simplified logic vs tcp sockets - one socket type and only one",
"# possible location ... | [
23,
0
] | [
48,
34
] | python | en | ['en', 'en', 'en'] | True |
load_mpi_test | (file_path, seq, norm) |
Usage: Load a section once
:param dataset_root: root path
:param section: There are six sequences in this (seq=0,1,2,3,4,5). And 2935 poses in a unique set(seq==7).
If you want to evaluate by scene setting, you can use the sequencewise evaluation
to convert to these numbers by doing
#1:Studio w... |
Usage: Load a section once
:param dataset_root: root path
:param section: There are six sequences in this (seq=0,1,2,3,4,5). And 2935 poses in a unique set(seq==7).
If you want to evaluate by scene setting, you can use the sequencewise evaluation
to convert to these numbers by doing
#1:Studio w... | def load_mpi_test(file_path, seq, norm):
"""
Usage: Load a section once
:param dataset_root: root path
:param section: There are six sequences in this (seq=0,1,2,3,4,5). And 2935 poses in a unique set(seq==7).
If you want to evaluate by scene setting, you can use the sequencewise evaluation
to c... | [
"def",
"load_mpi_test",
"(",
"file_path",
",",
"seq",
",",
"norm",
")",
":",
"info",
"=",
"np",
".",
"load",
"(",
"file_path",
",",
"allow_pickle",
"=",
"True",
")",
"if",
"seq",
"in",
"range",
"(",
"0",
",",
"6",
")",
":",
"pose_3d",
"=",
"info",
... | [
4,
0
] | [
44,
49
] | python | en | ['en', 'error', 'th'] | False |
download_selenium_server | () |
Downloads the Selenium Server JAR file from its
online location and stores it locally.
|
Downloads the Selenium Server JAR file from its
online location and stores it locally.
| def download_selenium_server():
"""
Downloads the Selenium Server JAR file from its
online location and stores it locally.
"""
try:
local_file = open(JAR_FILE, 'wb')
remote_file = urlopen(SELENIUM_JAR)
print('Downloading the Selenium Server JAR file...\n')
local_file.... | [
"def",
"download_selenium_server",
"(",
")",
":",
"try",
":",
"local_file",
"=",
"open",
"(",
"JAR_FILE",
",",
"'wb'",
")",
"remote_file",
"=",
"urlopen",
"(",
"SELENIUM_JAR",
")",
"print",
"(",
"'Downloading the Selenium Server JAR file...\\n'",
")",
"local_file",
... | [
20,
0
] | [
35,
58
] | python | en | ['en', 'error', 'th'] | False |
impl_details.is_defined_in_xxx | (xxx, cls) |
Small helper method that checks whether the class `cls` is defined
under `::xxx` namespace
|
Small helper method that checks whether the class `cls` is defined
under `::xxx` namespace
| def is_defined_in_xxx(xxx, cls):
"""
Small helper method that checks whether the class `cls` is defined
under `::xxx` namespace
"""
if not cls.parent:
return False
if not isinstance(cls.parent, namespace.namespace_t):
return False
if xxx ... | [
"def",
"is_defined_in_xxx",
"(",
"xxx",
",",
"cls",
")",
":",
"if",
"not",
"cls",
".",
"parent",
":",
"return",
"False",
"if",
"not",
"isinstance",
"(",
"cls",
".",
"parent",
",",
"namespace",
".",
"namespace_t",
")",
":",
"return",
"False",
"if",
"xxx... | [
16,
4
] | [
41,
39
] | python | en | ['en', 'error', 'th'] | False |
impl_details.find_value_type | (global_ns, value_type_str) | implementation details | implementation details | def find_value_type(global_ns, value_type_str):
"""implementation details"""
if not value_type_str.startswith('::'):
value_type_str = '::' + value_type_str
found = global_ns.decls(
name=value_type_str,
function=lambda decl: not isinstance(decl, calldef.calldef... | [
"def",
"find_value_type",
"(",
"global_ns",
",",
"value_type_str",
")",
":",
"if",
"not",
"value_type_str",
".",
"startswith",
"(",
"'::'",
")",
":",
"value_type_str",
"=",
"'::'",
"+",
"value_type_str",
"found",
"=",
"global_ns",
".",
"decls",
"(",
"name",
... | [
44,
4
] | [
87,
23
] | python | da | ['eo', 'da', 'en'] | False |
internal_handler | (f) |
Reject requests where the remote address is not localhost. See the docstring
for _is_local_request() for important caveats!
|
Reject requests where the remote address is not localhost. See the docstring
for _is_local_request() for important caveats!
| def internal_handler(f):
"""
Reject requests where the remote address is not localhost. See the docstring
for _is_local_request() for important caveats!
"""
func_name = getattr(f, '__name__', '<anonymous>')
@functools.wraps(f)
def wrapper(*args, **kwds):
if not _is_local_request():
... | [
"def",
"internal_handler",
"(",
"f",
")",
":",
"func_name",
"=",
"getattr",
"(",
"f",
",",
"'__name__'",
",",
"'<anonymous>'",
")",
"@",
"functools",
".",
"wraps",
"(",
"f",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwds",
")",
":",
... | [
614,
0
] | [
627,
18
] | python | en | ['en', 'error', 'th'] | False |
_is_local_request | () |
Determine if this request originated with localhost.
When we are not running in LEGACY_MODE, we rely on healthcheck_server.go setting
the X-Ambassador-Diag-IP header for us (and we rely on it overwriting anything
that's already there!).
When we _are_ running in LEGACY_MODE, we rely on an implemen... |
Determine if this request originated with localhost. | def _is_local_request() -> bool:
"""
Determine if this request originated with localhost.
When we are not running in LEGACY_MODE, we rely on healthcheck_server.go setting
the X-Ambassador-Diag-IP header for us (and we rely on it overwriting anything
that's already there!).
When we _are_ runnin... | [
"def",
"_is_local_request",
"(",
")",
"->",
"bool",
":",
"remote_addr",
":",
"Optional",
"[",
"str",
"]",
"=",
"\"\"",
"if",
"not",
"app",
".",
"legacy_mode",
":",
"remote_addr",
"=",
"request",
".",
"headers",
".",
"get",
"(",
"\"X-Ambassador-Diag-IP\"",
... | [
633,
0
] | [
661,
37
] | python | en | ['en', 'error', 'th'] | False |
_allow_diag_ui | () |
Helper function to check if diag ui traffic is allowed or not
based on the different flags from the config:
* diagnostics.enabled: Enable to diag UI by adding mappings
* diagnostics.allow_non_local: Allow non local traffic
even when diagnotics UI is disabled.
... |
Helper function to check if diag ui traffic is allowed or not
based on the different flags from the config:
* diagnostics.enabled: Enable to diag UI by adding mappings
* diagnostics.allow_non_local: Allow non local traffic
even when diagnotics UI is disabled.
... | def _allow_diag_ui() -> bool:
"""
Helper function to check if diag ui traffic is allowed or not
based on the different flags from the config:
* diagnostics.enabled: Enable to diag UI by adding mappings
* diagnostics.allow_non_local: Allow non local traffic
even whe... | [
"def",
"_allow_diag_ui",
"(",
")",
"->",
"bool",
":",
"enabled",
"=",
"False",
"allow_non_local",
"=",
"False",
"ir",
"=",
"app",
".",
"ir",
"if",
"ir",
":",
"enabled",
"=",
"ir",
".",
"ambassador_module",
".",
"diagnostics",
".",
"get",
"(",
"\"enabled\... | [
664,
0
] | [
685,
15
] | python | en | ['en', 'error', 'th'] | False |
drop_serializer_key | (d: Dict[Any, Any]) |
Delete the "serialization" key (if present) in any dictionary passed in and
return that dictionary. This function is intended to be used as the
object_hook value for json.load[s].
|
Delete the "serialization" key (if present) in any dictionary passed in and
return that dictionary. This function is intended to be used as the
object_hook value for json.load[s].
| def drop_serializer_key(d: Dict[Any, Any]) -> Dict[Any, Any]:
"""
Delete the "serialization" key (if present) in any dictionary passed in and
return that dictionary. This function is intended to be used as the
object_hook value for json.load[s].
"""
_ = d.pop("serialization", None)
return d | [
"def",
"drop_serializer_key",
"(",
"d",
":",
"Dict",
"[",
"Any",
",",
"Any",
"]",
")",
"->",
"Dict",
"[",
"Any",
",",
"Any",
"]",
":",
"_",
"=",
"d",
".",
"pop",
"(",
"\"serialization\"",
",",
"None",
")",
"return",
"d"
] | [
813,
0
] | [
820,
12
] | python | en | ['en', 'error', 'th'] | False |
_main | (snapshot_path=None, bootstrap_path=None, ads_path=None,
*, dev_magic=False, config_path=None, ambex_pid=0, kick=None,
banner_endpoint="http://127.0.0.1:8500/banner", metrics_endpoint="http://127.0.0.1:8500/metrics", k8s=False,
no_checks=False, no_envoy=False, reload=False, debug=False, ve... |
Run the diagnostic daemon.
:param snapshot_path: Path to directory in which to save configuration snapshots and dynamic secrets
:param bootstrap_path: Path to which to write bootstrap Envoy configuration
:param ads_path: Path to which to write ADS Envoy configuration
:param config_path: Optional c... |
Run the diagnostic daemon. | def _main(snapshot_path=None, bootstrap_path=None, ads_path=None,
*, dev_magic=False, config_path=None, ambex_pid=0, kick=None,
banner_endpoint="http://127.0.0.1:8500/banner", metrics_endpoint="http://127.0.0.1:8500/metrics", k8s=False,
no_checks=False, no_envoy=False, reload=False, debug=... | [
"def",
"_main",
"(",
"snapshot_path",
"=",
"None",
",",
"bootstrap_path",
"=",
"None",
",",
"ads_path",
"=",
"None",
",",
"*",
",",
"dev_magic",
"=",
"False",
",",
"config_path",
"=",
"None",
",",
"ambex_pid",
"=",
"0",
",",
"kick",
"=",
"None",
",",
... | [
2103,
0
] | [
2188,
53
] | python | en | ['en', 'error', 'th'] | False |
DiagApp.diag | (self) |
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you.
You MUST NOT already hold the config_lock or the diag_lock when
trying to read app.diag.
You MUST already have... |
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you. | def diag(self) -> Optional[Diagnostics]:
"""
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you.
You MUST NOT already hold the config_lock or the diag_lock when
try... | [
"def",
"diag",
"(",
"self",
")",
"->",
"Optional",
"[",
"Diagnostics",
"]",
":",
"# The config_lock is meant to make sure that we don't ever update",
"# self.diag in two places at once, so grab that first.",
"with",
"self",
".",
"config_lock",
":",
"# If we've already generated d... | [
294,
4
] | [
340,
28
] | python | en | ['en', 'error', 'th'] | False |
DiagApp.diag | (self, diag: Optional[Diagnostics]) |
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you.
You MUST already hold the config_lock when trying to update app.diag.
You MUST NOT hold the diag_lock.
|
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you. | def diag(self, diag: Optional[Diagnostics]) -> None:
"""
It turns out to be expensive to generate the Diagnostics class, so
app.diag is a property that does it on demand, handling Timers and
the config lock for you.
You MUST already hold the config_lock when trying to update app... | [
"def",
"diag",
"(",
"self",
",",
"diag",
":",
"Optional",
"[",
"Diagnostics",
"]",
")",
"->",
"None",
":",
"self",
".",
"_diag",
"=",
"diag"
] | [
343,
4
] | [
352,
25
] | python | en | ['en', 'error', 'th'] | False |
DiagApp._generate_diagnostics | (self) |
Do the heavy lifting of generating Diagnostics for our current configuration.
Really, only the diag() property should be calling this method, but if you
are convinced that you need to call it from elsewhere:
1. You're almost certainly wrong about needing to call it from elsewhere.
... |
Do the heavy lifting of generating Diagnostics for our current configuration.
Really, only the diag() property should be calling this method, but if you
are convinced that you need to call it from elsewhere: | def _generate_diagnostics(self) -> Optional[Diagnostics]:
"""
Do the heavy lifting of generating Diagnostics for our current configuration.
Really, only the diag() property should be calling this method, but if you
are convinced that you need to call it from elsewhere:
1. You're... | [
"def",
"_generate_diagnostics",
"(",
"self",
")",
"->",
"Optional",
"[",
"Diagnostics",
"]",
":",
"# Make sure we have an IR and econf to work with.",
"if",
"not",
"app",
".",
"ir",
"or",
"not",
"app",
".",
"econf",
":",
"# Nope, bail.",
"return",
"None",
"# OK, g... | [
354,
4
] | [
386,
24
] | python | en | ['en', 'error', 'th'] | False |
create_expectation_suite | (
context,
datasource_name=None,
batch_kwargs_generator_name=None,
generator_asset=None,
batch_kwargs=None,
expectation_suite_name=None,
additional_batch_kwargs=None,
empty_suite=False,
show_intro_message=False,
flag_build_docs=True,
open_docs=False,
profiler_configuratio... |
Create a new expectation suite.
WARNING: the flow and name of this method and its interaction with _profile_to_create_a_suite
require a serious revisiting.
:return: a tuple: (success, suite name, profiling_results)
|
Create a new expectation suite. | def create_expectation_suite(
context,
datasource_name=None,
batch_kwargs_generator_name=None,
generator_asset=None,
batch_kwargs=None,
expectation_suite_name=None,
additional_batch_kwargs=None,
empty_suite=False,
show_intro_message=False,
flag_build_docs=True,
open_docs=Fals... | [
"def",
"create_expectation_suite",
"(",
"context",
",",
"datasource_name",
"=",
"None",
",",
"batch_kwargs_generator_name",
"=",
"None",
",",
"generator_asset",
"=",
"None",
",",
"batch_kwargs",
"=",
"None",
",",
"expectation_suite_name",
"=",
"None",
",",
"addition... | [
61,
0
] | [
162,
58
] | python | en | ['en', 'error', 'th'] | False |
load_expectation_suite | (
# TODO consolidate all the myriad CLI tests into this
context: DataContext,
suite_name: str,
usage_event: str,
) |
Load an expectation suite from a given context.
Handles a suite name with or without `.json`
:param usage_event:
|
Load an expectation suite from a given context. | def load_expectation_suite(
# TODO consolidate all the myriad CLI tests into this
context: DataContext,
suite_name: str,
usage_event: str,
) -> ExpectationSuite:
"""
Load an expectation suite from a given context.
Handles a suite name with or without `.json`
:param usage_event:
"""
... | [
"def",
"load_expectation_suite",
"(",
"# TODO consolidate all the myriad CLI tests into this",
"context",
":",
"DataContext",
",",
"suite_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
")",
"->",
"ExpectationSuite",
":",
"if",
"suite_name",
".",
"endswith",
"... | [
318,
0
] | [
341,
9
] | python | en | ['en', 'error', 'th'] | False |
load_checkpoint | (
context: DataContext,
checkpoint_name: str,
usage_event: str,
) | Load a checkpoint or raise helpful errors. | Load a checkpoint or raise helpful errors. | def load_checkpoint(
context: DataContext,
checkpoint_name: str,
usage_event: str,
) -> Union[Checkpoint, LegacyCheckpoint]:
"""Load a checkpoint or raise helpful errors."""
try:
checkpoint: Union[Checkpoint, LegacyCheckpoint] = context.get_checkpoint(
name=checkpoint_name
... | [
"def",
"load_checkpoint",
"(",
"context",
":",
"DataContext",
",",
"checkpoint_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
")",
"->",
"Union",
"[",
"Checkpoint",
",",
"LegacyCheckpoint",
"]",
":",
"try",
":",
"checkpoint",
":",
"Union",
"[",
"C... | [
352,
0
] | [
376,
84
] | python | en | ['en', 'en', 'en'] | True |
select_datasource | (context: DataContext, datasource_name: str = None) | Select a datasource interactively. | Select a datasource interactively. | def select_datasource(context: DataContext, datasource_name: str = None) -> Datasource:
"""Select a datasource interactively."""
# TODO consolidate all the myriad CLI tests into this
data_source = None
if datasource_name is None:
data_sources = sorted(context.list_datasources(), key=lambda x: x... | [
"def",
"select_datasource",
"(",
"context",
":",
"DataContext",
",",
"datasource_name",
":",
"str",
"=",
"None",
")",
"->",
"Datasource",
":",
"# TODO consolidate all the myriad CLI tests into this",
"data_source",
"=",
"None",
"if",
"datasource_name",
"is",
"None",
"... | [
379,
0
] | [
411,
22
] | python | en | ['en', 'en', 'en'] | True |
load_data_context_with_error_handling | (
directory: str, from_cli_upgrade_command: bool = False
) | Return a DataContext with good error handling and exit codes. | Return a DataContext with good error handling and exit codes. | def load_data_context_with_error_handling(
directory: str, from_cli_upgrade_command: bool = False
) -> DataContext:
"""Return a DataContext with good error handling and exit codes."""
try:
context: DataContext = DataContext(context_root_dir=directory)
ge_config_version: int = context.get_con... | [
"def",
"load_data_context_with_error_handling",
"(",
"directory",
":",
"str",
",",
"from_cli_upgrade_command",
":",
"bool",
"=",
"False",
")",
"->",
"DataContext",
":",
"try",
":",
"context",
":",
"DataContext",
"=",
"DataContext",
"(",
"context_root_dir",
"=",
"d... | [
414,
0
] | [
471,
19
] | python | en | ['en', 'en', 'en'] | True |
confirm_proceed_or_exit | (
confirm_prompt: str = "Would you like to proceed?",
continuation_message: str = "Ok, exiting now. You can always read more at https://docs.greatexpectations.io/ !",
exit_on_no: bool = True,
exit_code: int = 0,
) |
Every CLI command that starts a potentially lengthy (>1 sec) computation
or modifies some resources (e.g., edits the config file, adds objects
to the stores) must follow this pattern:
1. Explain which resources will be created/modified/deleted
2. Use this method to ask for user's confirmation
... |
Every CLI command that starts a potentially lengthy (>1 sec) computation
or modifies some resources (e.g., edits the config file, adds objects
to the stores) must follow this pattern:
1. Explain which resources will be created/modified/deleted
2. Use this method to ask for user's confirmation | def confirm_proceed_or_exit(
confirm_prompt: str = "Would you like to proceed?",
continuation_message: str = "Ok, exiting now. You can always read more at https://docs.greatexpectations.io/ !",
exit_on_no: bool = True,
exit_code: int = 0,
) -> Optional[bool]:
"""
Every CLI command that starts a ... | [
"def",
"confirm_proceed_or_exit",
"(",
"confirm_prompt",
":",
"str",
"=",
"\"Would you like to proceed?\"",
",",
"continuation_message",
":",
"str",
"=",
"\"Ok, exiting now. You can always read more at https://docs.greatexpectations.io/ !\"",
",",
"exit_on_no",
":",
"bool",
"=",
... | [
599,
0
] | [
626,
15
] | python | en | ['en', 'error', 'th'] | False |
build_parameter_container_for_variables | (
variables_configs: Dict[str, Any]
) |
Build a ParameterContainer for all of the profiler config variables passed as key value pairs
Args:
variables_configs: Variable key: value pairs e.g. {"variable_name": variable_value, ...}
Returns:
ParameterContainer containing all variables
|
Build a ParameterContainer for all of the profiler config variables passed as key value pairs
Args:
variables_configs: Variable key: value pairs e.g. {"variable_name": variable_value, ...} | def build_parameter_container_for_variables(
variables_configs: Dict[str, Any]
) -> ParameterContainer:
"""
Build a ParameterContainer for all of the profiler config variables passed as key value pairs
Args:
variables_configs: Variable key: value pairs e.g. {"variable_name": variable_value, ...}... | [
"def",
"build_parameter_container_for_variables",
"(",
"variables_configs",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"ParameterContainer",
":",
"variable_config_key",
":",
"str",
"variable_config_value",
":",
"Any",
"parameter_values",
":",
"Dict",
"[",
... | [
132,
0
] | [
155,
30
] | python | en | ['en', 'error', 'th'] | False |
build_parameter_container | (
parameter_container: ParameterContainer,
parameter_values: Dict[str, Any],
) |
Builds the ParameterNode trees, corresponding to the fully_qualified_parameter_name first-level keys.
:param parameter_container initialized ParameterContainer for all ParameterNode trees
:param parameter_values
Example of the name-value structure for building parameters (matching the type hint in the... |
Builds the ParameterNode trees, corresponding to the fully_qualified_parameter_name first-level keys. | def build_parameter_container(
parameter_container: ParameterContainer,
parameter_values: Dict[str, Any],
):
"""
Builds the ParameterNode trees, corresponding to the fully_qualified_parameter_name first-level keys.
:param parameter_container initialized ParameterContainer for all ParameterNode tree... | [
"def",
"build_parameter_container",
"(",
"parameter_container",
":",
"ParameterContainer",
",",
"parameter_values",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
")",
":",
"parameter_node",
":",
"Optional",
"[",
"ParameterNode",
"]",
"fully_qualified_parameter_name",... | [
158,
0
] | [
218,
9
] | python | en | ['en', 'error', 'th'] | False |
_build_parameter_node_tree_for_one_parameter | (
parameter_node: ParameterNode,
parameter_name_as_list: List[str],
parameter_value: Any,
) |
Recursively builds a tree of ParameterNode objects, creating new ParameterNode objects parsimoniously (i.e., only if
ParameterNode object, corresponding to a part of fully-qualified parameter names in a "name space" does not exist).
:param parameter_node: root-level ParameterNode for the sub-tree, characte... |
Recursively builds a tree of ParameterNode objects, creating new ParameterNode objects parsimoniously (i.e., only if
ParameterNode object, corresponding to a part of fully-qualified parameter names in a "name space" does not exist).
:param parameter_node: root-level ParameterNode for the sub-tree, characte... | def _build_parameter_node_tree_for_one_parameter(
parameter_node: ParameterNode,
parameter_name_as_list: List[str],
parameter_value: Any,
):
"""
Recursively builds a tree of ParameterNode objects, creating new ParameterNode objects parsimoniously (i.e., only if
ParameterNode object, correspondin... | [
"def",
"_build_parameter_node_tree_for_one_parameter",
"(",
"parameter_node",
":",
"ParameterNode",
",",
"parameter_name_as_list",
":",
"List",
"[",
"str",
"]",
",",
"parameter_value",
":",
"Any",
",",
")",
":",
"parameter_name_part",
":",
"str",
"=",
"parameter_name_... | [
221,
0
] | [
248,
61
] | python | en | ['en', 'error', 'th'] | False |
get_parameter_value_by_fully_qualified_parameter_name | (
fully_qualified_parameter_name: str,
domain: Optional[Domain] = None,
variables: Optional[ParameterContainer] = None,
parameters: Optional[Dict[str, ParameterContainer]] = None,
) |
Get the parameter value from the current rule state using the fully-qualified parameter name.
A fully-qualified parameter name must be a dot-delimited string, or the name of a parameter (without the dots).
Args
:param fully_qualified_parameter_name: str -- A dot-separated string key starting with $... |
Get the parameter value from the current rule state using the fully-qualified parameter name.
A fully-qualified parameter name must be a dot-delimited string, or the name of a parameter (without the dots).
Args
:param fully_qualified_parameter_name: str -- A dot-separated string key starting with $... | def get_parameter_value_by_fully_qualified_parameter_name(
fully_qualified_parameter_name: str,
domain: Optional[Domain] = None,
variables: Optional[ParameterContainer] = None,
parameters: Optional[Dict[str, ParameterContainer]] = None,
) -> Optional[Union[Any, ParameterNode]]:
"""
Get the param... | [
"def",
"get_parameter_value_by_fully_qualified_parameter_name",
"(",
"fully_qualified_parameter_name",
":",
"str",
",",
"domain",
":",
"Optional",
"[",
"Domain",
"]",
"=",
"None",
",",
"variables",
":",
"Optional",
"[",
"ParameterContainer",
"]",
"=",
"None",
",",
"... | [
251,
0
] | [
315,
5
] | python | en | ['en', 'error', 'th'] | False |
linear_move | (joint: tuple, point: tuple) | Take a joint and applies a cartesian relative-move | Take a joint and applies a cartesian relative-move | def linear_move(joint: tuple, point: tuple) -> tuple:
"""Take a joint and applies a cartesian relative-move"""
c_joint = forward_kinematics(*joint)
pos = inverse_kinematics(c_joint[0] + point[0], c_joint[1] + point[1])
return pos[0], pos[1], joint[2] | [
"def",
"linear_move",
"(",
"joint",
":",
"tuple",
",",
"point",
":",
"tuple",
")",
"->",
"tuple",
":",
"c_joint",
"=",
"forward_kinematics",
"(",
"*",
"joint",
")",
"pos",
"=",
"inverse_kinematics",
"(",
"c_joint",
"[",
"0",
"]",
"+",
"point",
"[",
"0"... | [
8,
0
] | [
15,
35
] | python | en | ['en', 'en', 'en'] | True |
inverse_kinematics | (x: float, y: float) | Computes the inverse kinematics for a planar 2DOF arm | Computes the inverse kinematics for a planar 2DOF arm | def inverse_kinematics(x: float, y: float) -> tuple:
"""Computes the inverse kinematics for a planar 2DOF arm"""
try:
theta2 = round(math.acos((y ** 2 + x ** 2 - l1 ** 2 - l2 ** 2) / (2 * l1 * l2)), 3)
theta1 = round(math.atan2(x, y) - math.atan2(l2 * math.sin(theta2), (l1 + l2 * math.cos(thet... | [
"def",
"inverse_kinematics",
"(",
"x",
":",
"float",
",",
"y",
":",
"float",
")",
"->",
"tuple",
":",
"try",
":",
"theta2",
"=",
"round",
"(",
"math",
".",
"acos",
"(",
"(",
"y",
"**",
"2",
"+",
"x",
"**",
"2",
"-",
"l1",
"**",
"2",
"-",
"l2"... | [
18,
0
] | [
35,
31
] | python | en | ['en', 'en', 'en'] | True |
forward_kinematics | (theta1: float, theta2: float, theta3=0.0) | Computes the forward kinematics for a planar 2DOF arm | Computes the forward kinematics for a planar 2DOF arm | def forward_kinematics(theta1: float, theta2: float, theta3=0.0) -> tuple:
"""Computes the forward kinematics for a planar 2DOF arm"""
theta1 = math.radians((theta1 + OFFSET[0]) * 36)
theta2 = math.radians((theta2 + OFFSET[1]) * 36)
arm1_pos = (l1 * math.cos(theta2), l1 * math.sin(theta2))
arm2_p... | [
"def",
"forward_kinematics",
"(",
"theta1",
":",
"float",
",",
"theta2",
":",
"float",
",",
"theta3",
"=",
"0.0",
")",
"->",
"tuple",
":",
"theta1",
"=",
"math",
".",
"radians",
"(",
"(",
"theta1",
"+",
"OFFSET",
"[",
"0",
"]",
")",
"*",
"36",
")",... | [
38,
0
] | [
48,
19
] | python | en | ['en', 'ga', 'en'] | True |
gaussian_fit | (x, y, x_smooth=None, n_pts=200) |
Fits a Gaussian to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the data to fit to.
x_smooth: list-like
The exact x values to interpolate for. Superce... |
Fits a Gaussian to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the data to fit to.
x_smooth: list-like
The exact x values to interpolate for. Superce... | def gaussian_fit(x, y, x_smooth=None, n_pts=200):
"""
Fits a Gaussian to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the data to fit to.
x_smooth: list-li... | [
"def",
"gaussian_fit",
"(",
"x",
",",
"y",
",",
"x_smooth",
"=",
"None",
",",
"n_pts",
"=",
"200",
")",
":",
"if",
"x_smooth",
"is",
"None",
":",
"x_smooth",
"=",
"np",
".",
"linspace",
"(",
"x",
".",
"min",
"(",
")",
",",
"x",
".",
"max",
"(",... | [
6,
0
] | [
25,
32
] | python | en | ['en', 'error', 'th'] | False |
poly_fit | (x, y, degree, x_smooth=None, n_pts=200) |
Fits a polynomial of any positive integer degree to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the data to fit to.
x_smooth: list-like
The exact x v... |
Fits a polynomial of any positive integer degree to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the data to fit to.
x_smooth: list-like
The exact x v... | def poly_fit(x, y, degree, x_smooth=None, n_pts=200):
"""
Fits a polynomial of any positive integer degree to some data - x and y. Returns predicted interpolation values.
Parameters
----------
x: list-like
The x values of the data to fit to.
y: list-like
The y values of the ... | [
"def",
"poly_fit",
"(",
"x",
",",
"y",
",",
"degree",
",",
"x_smooth",
"=",
"None",
",",
"n_pts",
"=",
"200",
")",
":",
"if",
"x_smooth",
"is",
"None",
":",
"x_smooth",
"=",
"np",
".",
"linspace",
"(",
"x",
".",
"min",
"(",
")",
",",
"x",
".",
... | [
27,
0
] | [
47,
115
] | python | en | ['en', 'error', 'th'] | False |
test_cli_init_on_existing_project_with_no_uncommitted_dirs_answering_no_then_yes_to_fixing_them | (
caplog,
monkeypatch,
tmp_path,
) |
This test walks through the onboarding experience.
The user just checked an existing project out of source control and does
not yet have an uncommitted directory.
|
This test walks through the onboarding experience. | def test_cli_init_on_existing_project_with_no_uncommitted_dirs_answering_no_then_yes_to_fixing_them(
caplog,
monkeypatch,
tmp_path,
):
"""
This test walks through the onboarding experience.
The user just checked an existing project out of source control and does
not yet have an uncommitted ... | [
"def",
"test_cli_init_on_existing_project_with_no_uncommitted_dirs_answering_no_then_yes_to_fixing_them",
"(",
"caplog",
",",
"monkeypatch",
",",
"tmp_path",
",",
")",
":",
"root_dir_path",
"=",
"tmp_path",
"/",
"\"hiya\"",
"root_dir_path",
".",
"mkdir",
"(",
")",
"root_dir... | [
187,
0
] | [
285,
60
] | python | en | ['en', 'error', 'th'] | False |
is_same_function | (f1, f2) | returns true if f1 and f2 is same function
Use case: sometimes when user defines some virtual function in base class,
it overrides it in a derived one. Sometimes we need to know whether two
member functions is actually same function.
| returns true if f1 and f2 is same function | def is_same_function(f1, f2):
"""returns true if f1 and f2 is same function
Use case: sometimes when user defines some virtual function in base class,
it overrides it in a derived one. Sometimes we need to know whether two
member functions is actually same function.
"""
if f1 is f2:
ret... | [
"def",
"is_same_function",
"(",
"f1",
",",
"f2",
")",
":",
"if",
"f1",
"is",
"f2",
":",
"return",
"True",
"if",
"f1",
".",
"__class__",
"is",
"not",
"f2",
".",
"__class__",
":",
"return",
"False",
"if",
"isinstance",
"(",
"f1",
",",
"calldef_members",
... | [
72,
0
] | [
95,
15
] | python | en | ['en', 'en', 'en'] | True |
from_dataset | (cls, dataset=None) | This base implementation naively passes arguments on to the real constructor, which
is suitable really when a constructor knows to take its own type. In general, this should be overridden | This base implementation naively passes arguments on to the real constructor, which
is suitable really when a constructor knows to take its own type. In general, this should be overridden | def from_dataset(cls, dataset=None):
"""This base implementation naively passes arguments on to the real constructor, which
is suitable really when a constructor knows to take its own type. In general, this should be overridden"""
return cls(dataset) | [
"def",
"from_dataset",
"(",
"cls",
",",
"dataset",
"=",
"None",
")",
":",
"return",
"cls",
"(",
"dataset",
")"
] | [
246,
4
] | [
249,
27
] | python | en | ['en', 'en', 'en'] | True |
get_row_count | (self) | Returns: int, table row count | Returns: int, table row count | def get_row_count(self):
"""Returns: int, table row count"""
raise NotImplementedError | [
"def",
"get_row_count",
"(",
"self",
")",
":",
"raise",
"NotImplementedError"
] | [
251,
4
] | [
253,
33
] | python | en | ['en', 'en', 'en'] | True |
get_column_count | (self) | Returns: int, table column count | Returns: int, table column count | def get_column_count(self):
"""Returns: int, table column count"""
raise NotImplementedError | [
"def",
"get_column_count",
"(",
"self",
")",
":",
"raise",
"NotImplementedError"
] | [
255,
4
] | [
257,
33
] | python | en | ['en', 'en', 'en'] | True |
get_table_columns | (self) | Returns: List[str], list of column names | Returns: List[str], list of column names | def get_table_columns(self) -> List[str]:
"""Returns: List[str], list of column names"""
raise NotImplementedError | [
"def",
"get_table_columns",
"(",
"self",
")",
"->",
"List",
"[",
"str",
"]",
":",
"raise",
"NotImplementedError"
] | [
259,
4
] | [
261,
33
] | python | en | ['en', 'is', 'en'] | True |
get_column_nonnull_count | (self, column) | Returns: int | Returns: int | def get_column_nonnull_count(self, column):
"""Returns: int"""
raise NotImplementedError | [
"def",
"get_column_nonnull_count",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
263,
4
] | [
265,
33
] | python | en | ['en', 'bg', 'en'] | False |
get_column_mean | (self, column) | Returns: float | Returns: float | def get_column_mean(self, column):
"""Returns: float"""
raise NotImplementedError | [
"def",
"get_column_mean",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
267,
4
] | [
269,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_value_counts | (self, column, sort="value", collate=None) | Get a series containing the frequency counts of unique values from the named column.
Args:
column: the column for which to obtain value_counts
sort (string): must be one of "value", "count", or "none".
- if "value" then values in the resulting partition object will be so... | Get a series containing the frequency counts of unique values from the named column. | def get_column_value_counts(self, column, sort="value", collate=None):
"""Get a series containing the frequency counts of unique values from the named column.
Args:
column: the column for which to obtain value_counts
sort (string): must be one of "value", "count", or "none".
... | [
"def",
"get_column_value_counts",
"(",
"self",
",",
"column",
",",
"sort",
"=",
"\"value\"",
",",
"collate",
"=",
"None",
")",
":",
"raise",
"NotImplementedError"
] | [
271,
4
] | [
286,
33
] | python | en | ['en', 'en', 'en'] | True |
get_column_sum | (self, column) | Returns: float | Returns: float | def get_column_sum(self, column):
"""Returns: float"""
raise NotImplementedError | [
"def",
"get_column_sum",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
288,
4
] | [
290,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_max | (self, column, parse_strings_as_datetimes=False) | Returns: Any | Returns: Any | def get_column_max(self, column, parse_strings_as_datetimes=False):
"""Returns: Any"""
raise NotImplementedError | [
"def",
"get_column_max",
"(",
"self",
",",
"column",
",",
"parse_strings_as_datetimes",
"=",
"False",
")",
":",
"raise",
"NotImplementedError"
] | [
292,
4
] | [
294,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_min | (self, column, parse_strings_as_datetimes=False) | Returns: Any | Returns: Any | def get_column_min(self, column, parse_strings_as_datetimes=False):
"""Returns: Any"""
raise NotImplementedError | [
"def",
"get_column_min",
"(",
"self",
",",
"column",
",",
"parse_strings_as_datetimes",
"=",
"False",
")",
":",
"raise",
"NotImplementedError"
] | [
296,
4
] | [
298,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_unique_count | (self, column) | Returns: int | Returns: int | def get_column_unique_count(self, column):
"""Returns: int"""
raise NotImplementedError | [
"def",
"get_column_unique_count",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
300,
4
] | [
302,
33
] | python | en | ['en', 'bg', 'en'] | False |
get_column_modes | (self, column) | Returns: List[Any], list of modes (ties OK) | Returns: List[Any], list of modes (ties OK) | def get_column_modes(self, column):
"""Returns: List[Any], list of modes (ties OK)"""
raise NotImplementedError | [
"def",
"get_column_modes",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
304,
4
] | [
306,
33
] | python | en | ['en', 'et', 'en'] | True |
get_column_median | (self, column) | Returns: Any | Returns: Any | def get_column_median(self, column):
"""Returns: Any"""
raise NotImplementedError | [
"def",
"get_column_median",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
308,
4
] | [
310,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_quantiles | (
self, column, quantiles, allow_relative_error=False
) | Get the values in column closest to the requested quantiles
Args:
column (string): name of column
quantiles (tuple of float): the quantiles to return. quantiles \
*must* be a tuple to ensure caching is possible
Returns:
List[Any]: the nearest values in th... | Get the values in column closest to the requested quantiles
Args:
column (string): name of column
quantiles (tuple of float): the quantiles to return. quantiles \
*must* be a tuple to ensure caching is possible | def get_column_quantiles(
self, column, quantiles, allow_relative_error=False
) -> List[Any]:
"""Get the values in column closest to the requested quantiles
Args:
column (string): name of column
quantiles (tuple of float): the quantiles to return. quantiles \
... | [
"def",
"get_column_quantiles",
"(",
"self",
",",
"column",
",",
"quantiles",
",",
"allow_relative_error",
"=",
"False",
")",
"->",
"List",
"[",
"Any",
"]",
":",
"raise",
"NotImplementedError"
] | [
312,
4
] | [
324,
33
] | python | en | ['en', 'en', 'en'] | True |
get_column_stdev | (self, column) | Returns: float | Returns: float | def get_column_stdev(self, column):
"""Returns: float"""
raise NotImplementedError | [
"def",
"get_column_stdev",
"(",
"self",
",",
"column",
")",
":",
"raise",
"NotImplementedError"
] | [
326,
4
] | [
328,
33
] | python | en | ['en', 'no', 'en'] | False |
get_column_partition | (
self, column, bins="uniform", n_bins=10, allow_relative_error=False
) | Get a partition of the range of values in the specified column.
Args:
column: the name of the column
bins: 'uniform' for evenly spaced bins or 'quantile' for bins spaced according to quantiles
n_bins: the number of bins to produce
allow_relative_error: passed to ... | Get a partition of the range of values in the specified column. | def get_column_partition(
self, column, bins="uniform", n_bins=10, allow_relative_error=False
):
"""Get a partition of the range of values in the specified column.
Args:
column: the name of the column
bins: 'uniform' for evenly spaced bins or 'quantile' for bins spac... | [
"def",
"get_column_partition",
"(",
"self",
",",
"column",
",",
"bins",
"=",
"\"uniform\"",
",",
"n_bins",
"=",
"10",
",",
"allow_relative_error",
"=",
"False",
")",
":",
"if",
"bins",
"==",
"\"uniform\"",
":",
"# TODO: in the event that we shift the compute model f... | [
330,
4
] | [
386,
19
] | python | en | ['en', 'en', 'en'] | True |
get_column_hist | (self, column, bins) | Get a histogram of column values
Args:
column: the column for which to generate the histogram
bins (tuple): the bins to slice the histogram. bins *must* be a tuple to ensure caching is possible
Returns: List[int], a list of counts corresponding to bins | Get a histogram of column values
Args:
column: the column for which to generate the histogram
bins (tuple): the bins to slice the histogram. bins *must* be a tuple to ensure caching is possible | def get_column_hist(self, column, bins):
"""Get a histogram of column values
Args:
column: the column for which to generate the histogram
bins (tuple): the bins to slice the histogram. bins *must* be a tuple to ensure caching is possible
Returns: List[int], a list of cou... | [
"def",
"get_column_hist",
"(",
"self",
",",
"column",
",",
"bins",
")",
":",
"raise",
"NotImplementedError"
] | [
388,
4
] | [
395,
33
] | python | en | ['en', 'ca', 'en'] | True |
get_column_count_in_range | (
self, column, min_val=None, max_val=None, strict_min=False, strict_max=True
) | Returns: int | Returns: int | def get_column_count_in_range(
self, column, min_val=None, max_val=None, strict_min=False, strict_max=True
):
"""Returns: int"""
raise NotImplementedError | [
"def",
"get_column_count_in_range",
"(",
"self",
",",
"column",
",",
"min_val",
"=",
"None",
",",
"max_val",
"=",
"None",
",",
"strict_min",
"=",
"False",
",",
"strict_max",
"=",
"True",
")",
":",
"raise",
"NotImplementedError"
] | [
397,
4
] | [
401,
33
] | python | en | ['en', 'bg', 'en'] | False |
get_crosstab | (
self,
column_A,
column_B,
bins_A=None,
bins_B=None,
n_bins_A=None,
n_bins_B=None,
) | Get crosstab of column_A and column_B, binning values if necessary | Get crosstab of column_A and column_B, binning values if necessary | def get_crosstab(
self,
column_A,
column_B,
bins_A=None,
bins_B=None,
n_bins_A=None,
n_bins_B=None,
):
"""Get crosstab of column_A and column_B, binning values if necessary"""
raise NotImplementedError | [
"def",
"get_crosstab",
"(",
"self",
",",
"column_A",
",",
"column_B",
",",
"bins_A",
"=",
"None",
",",
"bins_B",
"=",
"None",
",",
"n_bins_A",
"=",
"None",
",",
"n_bins_B",
"=",
"None",
",",
")",
":",
"raise",
"NotImplementedError"
] | [
403,
4
] | [
413,
33
] | python | en | ['en', 'en', 'en'] | True |
test_column_map_expectation_function | (self, function, *args, **kwargs) | Test a column map expectation function
Args:
function (func): The function to be tested. (Must be a valid column_map_expectation function.)
*args : Positional arguments to be passed the the function
**kwargs : Keyword arguments to be passed the the function
... | Test a column map expectation function | def test_column_map_expectation_function(self, function, *args, **kwargs):
"""Test a column map expectation function
Args:
function (func): The function to be tested. (Must be a valid column_map_expectation function.)
*args : Positional arguments to be passed the the fu... | [
"def",
"test_column_map_expectation_function",
"(",
"self",
",",
"function",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"new_function",
"=",
"self",
".",
"column_map_expectation",
"(",
"function",
")",
"return",
"new_function",
"(",
"self",
",",
"*",... | [
415,
4
] | [
435,
50
] | python | en | ['ca', 'en', 'en'] | True |
test_column_aggregate_expectation_function | (self, function, *args, **kwargs) | Test a column aggregate expectation function
Args:
function (func): The function to be tested. (Must be a valid column_aggregate_expectation function.)
*args : Positional arguments to be passed the the function
**kwargs : Keyword arguments to be passed the the... | Test a column aggregate expectation function | def test_column_aggregate_expectation_function(self, function, *args, **kwargs):
"""Test a column aggregate expectation function
Args:
function (func): The function to be tested. (Must be a valid column_aggregate_expectation function.)
*args : Positional arguments to be... | [
"def",
"test_column_aggregate_expectation_function",
"(",
"self",
",",
"function",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"new_function",
"=",
"self",
".",
"column_aggregate_expectation",
"(",
"function",
")",
"return",
"new_function",
"(",
"self",
... | [
437,
4
] | [
457,
50
] | python | en | ['es', 'en', 'en'] | True |
expect_column_to_exist | (
self,
column,
column_index=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the specified column to exist.
expect_column_to_exist is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Args:
column (str): \
The column n... | Expect the specified column to exist. | def expect_column_to_exist(
self,
column,
column_index=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the specified column to exist.
expect_column_to_exist is a :func:`expectation \
<great... | [
"def",
"expect_column_to_exist",
"(",
"self",
",",
"column",
",",
"column_index",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
",",
")",
":",
"columns",
... | [
467,
4
] | [
518,
37
] | python | en | ['en', 'en', 'en'] | True |
expect_table_columns_to_match_ordered_list | (
self,
column_list,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the columns to exactly match a specified list.
expect_table_columns_to_match_ordered_list is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Args:
column_l... | Expect the columns to exactly match a specified list. | def expect_table_columns_to_match_ordered_list(
self,
column_list,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the columns to exactly match a specified list.
expect_table_columns_to_match_ordered_list is a :... | [
"def",
"expect_table_columns_to_match_ordered_list",
"(",
"self",
",",
"column_list",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
",",
")",
":",
"columns",
"=",
"self",
... | [
522,
4
] | [
585,
13
] | python | en | ['en', 'en', 'en'] | True |
expect_table_columns_to_match_set | (
self,
column_set: Optional[Union[Set[str], List[str]]],
exact_match: Optional[bool] = True,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the columns to match a specified set.
expect_table_columns_to_match_set is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Args:
column_set (set of str or ... | Expect the columns to match a specified set. | def expect_table_columns_to_match_set(
self,
column_set: Optional[Union[Set[str], List[str]]],
exact_match: Optional[bool] = True,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the columns to match a specified ... | [
"def",
"expect_table_columns_to_match_set",
"(",
"self",
",",
"column_set",
":",
"Optional",
"[",
"Union",
"[",
"Set",
"[",
"str",
"]",
",",
"List",
"[",
"str",
"]",
"]",
"]",
",",
"exact_match",
":",
"Optional",
"[",
"bool",
"]",
"=",
"True",
",",
"re... | [
589,
4
] | [
678,
41
] | python | en | ['en', 'en', 'en'] | True |
expect_table_column_count_to_be_between | (
self,
min_value=None,
max_value=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the number of columns to be between two values.
expect_table_column_count_to_be_between is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Keyword Args:
mi... | Expect the number of columns to be between two values. | def expect_table_column_count_to_be_between(
self,
min_value=None,
max_value=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the number of columns to be between two values.
expect_table_column_coun... | [
"def",
"expect_table_column_count_to_be_between",
"(",
"self",
",",
"min_value",
"=",
"None",
",",
"max_value",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
... | [
683,
4
] | [
762,
79
] | python | en | ['en', 'en', 'en'] | True |
expect_table_column_count_to_equal | (
self,
value,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the number of columns to equal a value.
expect_table_column_count_to_equal is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Args:
value (int): \
... | Expect the number of columns to equal a value. | def expect_table_column_count_to_equal(
self,
value,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the number of columns to equal a value.
expect_table_column_count_to_equal is a :func:`expectation \
<... | [
"def",
"expect_table_column_count_to_equal",
"(",
"self",
",",
"value",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
",",
")",
":",
"try",
":",
"if",
"not",
"float",
... | [
767,
4
] | [
819,
9
] | python | en | ['en', 'en', 'en'] | True |
expect_table_row_count_to_be_between | (
self,
min_value=None,
max_value=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the number of rows to be between two values.
expect_table_row_count_to_be_between is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Keyword Args:
min_valu... | Expect the number of rows to be between two values. | def expect_table_row_count_to_be_between(
self,
min_value=None,
max_value=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the number of rows to be between two values.
expect_table_row_count_to_be_b... | [
"def",
"expect_table_row_count_to_be_between",
"(",
"self",
",",
"min_value",
"=",
"None",
",",
"max_value",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
","... | [
824,
4
] | [
906,
76
] | python | en | ['en', 'en', 'en'] | True |
expect_table_row_count_to_equal | (
self,
value,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the number of rows to equal a value.
expect_table_row_count_to_equal is a :func:`expectation \
<great_expectations.data_asset.data_asset.DataAsset.expectation>`, not a
``column_map_expectation`` or ``column_aggregate_expectation``.
Args:
value (int): \
... | Expect the number of rows to equal a value. | def expect_table_row_count_to_equal(
self,
value,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the number of rows to equal a value.
expect_table_row_count_to_equal is a :func:`expectation \
<great_exp... | [
"def",
"expect_table_row_count_to_equal",
"(",
"self",
",",
"value",
",",
"result_format",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptions",
"=",
"None",
",",
"meta",
"=",
"None",
",",
")",
":",
"try",
":",
"if",
"not",
"float",
"("... | [
911,
4
] | [
960,
87
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_unique | (
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect each column value to be unique.
This expectation detects duplicates. All duplicated values are counted as exceptions.
For example, `[1, 2, 3, 3, 3]` will return `[3, 3, 3]` in `result.exceptions_list`, with \
`unexpected_percent = 60.0`.
expect_column_values_to_be_unique is a \... | Expect each column value to be unique. | def expect_column_values_to_be_unique(
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect each column value to be unique.
... | [
"def",
"expect_column_values_to_be_unique",
"(",
"self",
",",
"column",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_except... | [
968,
4
] | [
1018,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_not_be_null | (
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column values to not be null.
To be counted as an exception, values must be explicitly null or missing, such as a NULL in PostgreSQL or an
np.NaN in pandas. Empty strings don't count as null unless they have been coerced to a null type.
expect_column_values_to_not_be_null is a \
... | Expect column values to not be null. | def expect_column_values_to_not_be_null(
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column values to not be null.
... | [
"def",
"expect_column_values_to_not_be_null",
"(",
"self",
",",
"column",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exce... | [
1020,
4
] | [
1073,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_null | (
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column values to be null.
expect_column_values_to_be_null is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
The column name.
Keyword Args:
mostly (None or ... | Expect column values to be null. | def expect_column_values_to_be_null(
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column values to be null.
expect... | [
"def",
"expect_column_values_to_be_null",
"(",
"self",
",",
"column",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catch_exceptio... | [
1075,
4
] | [
1125,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_of_type | (
self,
column,
type_,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect a column to contain values of a specified data type.
expect_column_values_to_be_of_type is a :func:`column_aggregate_expectation \
<great_expectations.dataset.dataset.MetaDataset.column_aggregate_expectation>` for typed-column backends,
and also for PandasDataset where the column dtype a... | Expect a column to contain values of a specified data type. | def expect_column_values_to_be_of_type(
self,
column,
type_,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect a column to contain val... | [
"def",
"expect_column_values_to_be_of_type",
"(",
"self",
",",
"column",
",",
"type_",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
"... | [
1127,
4
] | [
1192,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_in_type_list | (
self,
column,
type_list,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect a column to contain values from a specified type list.
expect_column_values_to_be_in_type_list is a :func:`column_aggregate_expectation \
<great_expectations.dataset.dataset.MetaDataset.column_aggregate_expectation>` for typed-column backends,
and also for PandasDataset where the column ... | Expect a column to contain values from a specified type list. | def expect_column_values_to_be_in_type_list(
self,
column,
type_list,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect a column to co... | [
"def",
"expect_column_values_to_be_in_type_list",
"(",
"self",
",",
"column",
",",
"type_list",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"T... | [
1194,
4
] | [
1256,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_in_set | (
self,
column,
value_set,
mostly=None,
parse_strings_as_datetimes=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect each column value to be in a given set.
For example:
::
# my_df.my_col = [1,2,2,3,3,3]
>>> my_df.expect_column_values_to_be_in_set(
"my_col",
[2,3]
)
{
"success": false
"result": {
... | Expect each column value to be in a given set. | def expect_column_values_to_be_in_set(
self,
column,
value_set,
mostly=None,
parse_strings_as_datetimes=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
... | [
"def",
"expect_column_values_to_be_in_set",
"(",
"self",
",",
"column",
",",
"value_set",
",",
"mostly",
"=",
"None",
",",
"parse_strings_as_datetimes",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"="... | [
1264,
4
] | [
1341,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_not_be_in_set | (
self,
column,
value_set,
mostly=None,
parse_strings_as_datetimes=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to not be in the set.
For example:
::
# my_df.my_col = [1,2,2,3,3,3]
>>> my_df.expect_column_values_to_not_be_in_set(
"my_col",
[1,2]
)
{
"success": false
"result": {
... | Expect column entries to not be in the set. | def expect_column_values_to_not_be_in_set(
self,
column,
value_set,
mostly=None,
parse_strings_as_datetimes=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
... | [
"def",
"expect_column_values_to_not_be_in_set",
"(",
"self",
",",
"column",
",",
"value_set",
",",
"mostly",
"=",
"None",
",",
"parse_strings_as_datetimes",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
... | [
1343,
4
] | [
1418,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_between | (
self,
column,
min_value=None,
max_value=None,
strict_min=False,
strict_max=False,
# tolerance=1e-9,
allow_cross_type_comparisons=None,
parse_strings_as_datetimes=False,
output_strftime_format=None,
mostly=None,
row_conditi... | Expect column entries to be between a minimum value and a maximum value (inclusive).
expect_column_values_to_be_between is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
The column na... | Expect column entries to be between a minimum value and a maximum value (inclusive). | def expect_column_values_to_be_between(
self,
column,
min_value=None,
max_value=None,
strict_min=False,
strict_max=False,
# tolerance=1e-9,
allow_cross_type_comparisons=None,
parse_strings_as_datetimes=False,
output_strftime_format=None,
... | [
"def",
"expect_column_values_to_be_between",
"(",
"self",
",",
"column",
",",
"min_value",
"=",
"None",
",",
"max_value",
"=",
"None",
",",
"strict_min",
"=",
"False",
",",
"strict_max",
"=",
"False",
",",
"# tolerance=1e-9,",
"allow_cross_type_comparisons",
"=",
... | [
1420,
4
] | [
1496,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_increasing | (
self,
column,
strictly=None,
parse_strings_as_datetimes=False,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column values to be increasing.
By default, this expectation only works for numeric or datetime data.
When `parse_strings_as_datetimes=True`, it can also parse strings to datetimes.
If `strictly=True`, then this expectation is only satisfied if each consecutive value
is strictly... | Expect column values to be increasing. | def expect_column_values_to_be_increasing(
self,
column,
strictly=None,
parse_strings_as_datetimes=False,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=N... | [
"def",
"expect_column_values_to_be_increasing",
"(",
"self",
",",
"column",
",",
"strictly",
"=",
"None",
",",
"parse_strings_as_datetimes",
"=",
"False",
",",
"mostly",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"... | [
1498,
4
] | [
1560,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_decreasing | (
self,
column,
strictly=None,
parse_strings_as_datetimes=False,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column values to be decreasing.
By default, this expectation only works for numeric or datetime data.
When `parse_strings_as_datetimes=True`, it can also parse strings to datetimes.
If `strictly=True`, then this expectation is only satisfied if each consecutive value
is strictly... | Expect column values to be decreasing. | def expect_column_values_to_be_decreasing(
self,
column,
strictly=None,
parse_strings_as_datetimes=False,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=N... | [
"def",
"expect_column_values_to_be_decreasing",
"(",
"self",
",",
"column",
",",
"strictly",
"=",
"None",
",",
"parse_strings_as_datetimes",
"=",
"False",
",",
"mostly",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"... | [
1562,
4
] | [
1624,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_value_lengths_to_be_between | (
self,
column,
min_value=None,
max_value=None,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be strings with length between a minimum value and a maximum value (inclusive).
This expectation only works for string-type values. Invoking it on ints or floats will raise a TypeError.
expect_column_value_lengths_to_be_between is a \
:func:`column_map_expectation <gre... | Expect column entries to be strings with length between a minimum value and a maximum value (inclusive). | def expect_column_value_lengths_to_be_between(
self,
column,
min_value=None,
max_value=None,
mostly=None,
row_condition=None,
condition_parser=None,
result_format=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
... | [
"def",
"expect_column_value_lengths_to_be_between",
"(",
"self",
",",
"column",
",",
"min_value",
"=",
"None",
",",
"max_value",
"=",
"None",
",",
"mostly",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"result_format... | [
1632,
4
] | [
1697,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_value_lengths_to_equal | (
self,
column,
value,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be strings with length equal to the provided value.
This expectation only works for string-type values. Invoking it on ints or floats will raise a TypeError.
expect_column_values_to_be_between is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.Met... | Expect column entries to be strings with length equal to the provided value. | def expect_column_value_lengths_to_equal(
self,
column,
value,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column entries to be ... | [
"def",
"expect_column_value_lengths_to_equal",
"(",
"self",
",",
"column",
",",
"value",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
... | [
1699,
4
] | [
1754,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_match_regex | (
self,
column,
regex,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be strings that match a given regular expression. Valid matches can be found \
anywhere in the string, for example "[at]+" will identify the following strings as expected: "cat", "hat", \
"aa", "a", and "t", and the following strings as unexpected: "fish", "dog".
expect... | Expect column entries to be strings that match a given regular expression. Valid matches can be found \
anywhere in the string, for example "[at]+" will identify the following strings as expected: "cat", "hat", \
"aa", "a", and "t", and the following strings as unexpected: "fish", "dog". | def expect_column_values_to_match_regex(
self,
column,
regex,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column entries to be s... | [
"def",
"expect_column_values_to_match_regex",
"(",
"self",
",",
"column",
",",
"regex",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
... | [
1756,
4
] | [
1814,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_not_match_regex | (
self,
column,
regex,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be strings that do NOT match a given regular expression. The regex must not match \
any portion of the provided string. For example, "[at]+" would identify the following strings as expected: \
"fish", "dog", and the following as unexpected: "cat", "hat".
expect_column_v... | Expect column entries to be strings that do NOT match a given regular expression. The regex must not match \
any portion of the provided string. For example, "[at]+" would identify the following strings as expected: \
"fish", "dog", and the following as unexpected: "cat", "hat". | def expect_column_values_to_not_match_regex(
self,
column,
regex,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column entries to ... | [
"def",
"expect_column_values_to_not_match_regex",
"(",
"self",
",",
"column",
",",
"regex",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True"... | [
1816,
4
] | [
1874,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_match_regex_list | (
self,
column,
regex_list,
match_on="any",
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the column entries to be strings that can be matched to either any of or all of a list of regular
expressions. Matches can be anywhere in the string.
expect_column_values_to_match_regex_list is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_e... | Expect the column entries to be strings that can be matched to either any of or all of a list of regular
expressions. Matches can be anywhere in the string. | def expect_column_values_to_match_regex_list(
self,
column,
regex_list,
match_on="any",
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
... | [
"def",
"expect_column_values_to_match_regex_list",
"(",
"self",
",",
"column",
",",
"regex_list",
",",
"match_on",
"=",
"\"any\"",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"No... | [
1876,
4
] | [
1938,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_not_match_regex_list | (
self,
column,
regex_list,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect the column entries to be strings that do not match any of a list of regular expressions. Matches can
be anywhere in the string.
expect_column_values_to_not_match_regex_list is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
... | Expect the column entries to be strings that do not match any of a list of regular expressions. Matches can
be anywhere in the string. | def expect_column_values_to_not_match_regex_list(
self,
column,
regex_list,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect the colu... | [
"def",
"expect_column_values_to_not_match_regex_list",
"(",
"self",
",",
"column",
",",
"regex_list",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"="... | [
1940,
4
] | [
1994,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_match_strftime_format | (
self,
column,
strftime_format,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be strings representing a date or time with a given format.
expect_column_values_to_match_strftime_format is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
Th... | Expect column entries to be strings representing a date or time with a given format. | def expect_column_values_to_match_strftime_format(
self,
column,
strftime_format,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect co... | [
"def",
"expect_column_values_to_match_strftime_format",
"(",
"self",
",",
"column",
",",
"strftime_format",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",... | [
2002,
4
] | [
2051,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_dateutil_parseable | (
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be parsable using dateutil.
expect_column_values_to_be_dateutil_parseable is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
The column name.
Keyword ... | Expect column entries to be parsable using dateutil. | def expect_column_values_to_be_dateutil_parseable(
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column entries to be parsab... | [
"def",
"expect_column_values_to_be_dateutil_parseable",
"(",
"self",
",",
"column",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"... | [
2053,
4
] | [
2099,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_be_json_parseable | (
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be data written in JavaScript Object Notation.
expect_column_values_to_be_json_parseable is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
The column name.
... | Expect column entries to be data written in JavaScript Object Notation. | def expect_column_values_to_be_json_parseable(
self,
column,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column entries to be data writt... | [
"def",
"expect_column_values_to_be_json_parseable",
"(",
"self",
",",
"column",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
"True",
",",
"catc... | [
2101,
4
] | [
2151,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_values_to_match_json_schema | (
self,
column,
json_schema,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) | Expect column entries to be JSON objects matching a given JSON schema.
expect_column_values_to_match_json_schema is a \
:func:`column_map_expectation <great_expectations.dataset.dataset.MetaDataset.column_map_expectation>`.
Args:
column (str): \
The column name.
... | Expect column entries to be JSON objects matching a given JSON schema. | def expect_column_values_to_match_json_schema(
self,
column,
json_schema,
mostly=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
):
"""Expect column ent... | [
"def",
"expect_column_values_to_match_json_schema",
"(",
"self",
",",
"column",
",",
"json_schema",
",",
"mostly",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
"condition_parser",
"=",
"None",
",",
"include_config",
"=",
... | [
2153,
4
] | [
2206,
33
] | python | en | ['en', 'en', 'en'] | True |
expect_column_parameterized_distribution_ks_test_p_value_to_be_greater_than | (
self,
column,
distribution,
p_value=0.05,
params=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=None,
meta=None,
) |
Expect the column values to be distributed similarly to a scipy distribution. \
This expectation compares the provided column to the specified continuous distribution with a parametric \
Kolmogorov-Smirnov test. The K-S test compares the provided column to the cumulative density function (CDF)... |
Expect the column values to be distributed similarly to a scipy distribution. \ | def expect_column_parameterized_distribution_ks_test_p_value_to_be_greater_than(
self,
column,
distribution,
p_value=0.05,
params=None,
result_format=None,
row_condition=None,
condition_parser=None,
include_config=True,
catch_exceptions=Non... | [
"def",
"expect_column_parameterized_distribution_ks_test_p_value_to_be_greater_than",
"(",
"self",
",",
"column",
",",
"distribution",
",",
"p_value",
"=",
"0.05",
",",
"params",
"=",
"None",
",",
"result_format",
"=",
"None",
",",
"row_condition",
"=",
"None",
",",
... | [
2214,
4
] | [
2297,
33
] | python | en | ['en', 'error', 'th'] | False |
MetaDataset.column_map_expectation | (cls, func) | Constructs an expectation using column-map semantics.
The column_map_expectation decorator handles boilerplate issues surrounding the common pattern of evaluating
truthiness of some condition on a per-row basis.
Args:
func (function): \
The function implementing a r... | Constructs an expectation using column-map semantics. | def column_map_expectation(cls, func):
"""Constructs an expectation using column-map semantics.
The column_map_expectation decorator handles boilerplate issues surrounding the common pattern of evaluating
truthiness of some condition on a per-row basis.
Args:
func (function... | [
"def",
"column_map_expectation",
"(",
"cls",
",",
"func",
")",
":",
"raise",
"NotImplementedError"
] | [
40,
4
] | [
70,
33
] | python | en | ['en', 'lb', 'en'] | True |
MetaDataset.column_aggregate_expectation | (cls, func) | Constructs an expectation using column-aggregate semantics.
The column_aggregate_expectation decorator handles boilerplate issues surrounding the common pattern of \
evaluating truthiness of some condition on an aggregated-column basis.
Args:
func (function): \
The ... | Constructs an expectation using column-aggregate semantics. | def column_aggregate_expectation(cls, func):
"""Constructs an expectation using column-aggregate semantics.
The column_aggregate_expectation decorator handles boilerplate issues surrounding the common pattern of \
evaluating truthiness of some condition on an aggregated-column basis.
A... | [
"def",
"column_aggregate_expectation",
"(",
"cls",
",",
"func",
")",
":",
"argspec",
"=",
"inspect",
".",
"getfullargspec",
"(",
"func",
")",
"[",
"0",
"]",
"[",
"1",
":",
"]",
"@",
"cls",
".",
"expectation",
"(",
"argspec",
")",
"@",
"wraps",
"(",
"... | [
73,
4
] | [
203,
28
] | python | en | ['en', 'en', 'en'] | True |
convert_error_to_string | (err, frames_to_skip_from_tail=None) |
:param frames_to_skip_from_tail: may be int or list of str. In latter case frames with these strings are skipped
| def convert_error_to_string(err, frames_to_skip_from_tail=None):
"""
:param frames_to_skip_from_tail: may be int or list of str. In latter case frames with these strings are skipped
"""
try:
if hasattr(err, "type") and hasattr(err, "value") and hasattr(err, "tb"):
exctype, value, tb... | [
"def",
"convert_error_to_string",
"(",
"err",
",",
"frames_to_skip_from_tail",
"=",
"None",
")",
":",
"try",
":",
"if",
"hasattr",
"(",
"err",
",",
"\"type\"",
")",
"and",
"hasattr",
"(",
"err",
",",
"\"value\"",
")",
"and",
"hasattr",
"(",
"err",
",",
"... | [
125,
0
] | [
150,
49
] | python | en | ['en', 'error', 'th'] | False | |
load_expectation_suite | (
data_context: DataContext,
expectation_suite_name: str,
usage_event: str,
suppress_usage_message: Optional[bool] = False,
create_if_not_exist: Optional[bool] = True,
) |
Load an expectation suite from a given context.
Handles a suite name with or without `.json`
:param data_context:
:param expectation_suite_name:
:param usage_event:
:param suppress_usage_message:
:param create_if_not_exist:
|
Load an expectation suite from a given context. | def load_expectation_suite(
data_context: DataContext,
expectation_suite_name: str,
usage_event: str,
suppress_usage_message: Optional[bool] = False,
create_if_not_exist: Optional[bool] = True,
) -> Optional[ExpectationSuite]:
"""
Load an expectation suite from a given context.
Handles ... | [
"def",
"load_expectation_suite",
"(",
"data_context",
":",
"DataContext",
",",
"expectation_suite_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
"suppress_usage_message",
":",
"Optional",
"[",
"bool",
"]",
"=",
"False",
",",
"create_if_not_exist",
":",
"O... | [
208,
0
] | [
249,
16
] | python | en | ['en', 'error', 'th'] | False |
delete_checkpoint | (
context: DataContext,
checkpoint_name: str,
usage_event: str,
assume_yes: bool,
) | Delete a Checkpoint or raise helpful errors. | Delete a Checkpoint or raise helpful errors. | def delete_checkpoint(
context: DataContext,
checkpoint_name: str,
usage_event: str,
assume_yes: bool,
):
"""Delete a Checkpoint or raise helpful errors."""
validate_checkpoint(
context=context,
checkpoint_name=checkpoint_name,
usage_event=usage_event,
)
confirm_p... | [
"def",
"delete_checkpoint",
"(",
"context",
":",
"DataContext",
",",
"checkpoint_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
"assume_yes",
":",
"bool",
",",
")",
":",
"validate_checkpoint",
"(",
"context",
"=",
"context",
",",
"checkpoint_name",
"=... | [
265,
0
] | [
289,
51
] | python | en | ['en', 'en', 'en'] | True |
run_checkpoint | (
context: DataContext,
checkpoint_name: str,
usage_event: str,
) | Run a Checkpoint or raise helpful errors. | Run a Checkpoint or raise helpful errors. | def run_checkpoint(
context: DataContext,
checkpoint_name: str,
usage_event: str,
) -> CheckpointResult:
"""Run a Checkpoint or raise helpful errors."""
failure_message: str = "Exception occurred while running Checkpoint."
validate_checkpoint(
context=context,
checkpoint_name=che... | [
"def",
"run_checkpoint",
"(",
"context",
":",
"DataContext",
",",
"checkpoint_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
")",
"->",
"CheckpointResult",
":",
"failure_message",
":",
"str",
"=",
"\"Exception occurred while running Checkpoint.\"",
"validate_... | [
292,
0
] | [
316,
9
] | python | en | ['en', 'gd', 'en'] | True |
load_checkpoint | (
context: DataContext,
checkpoint_name: str,
usage_event: str,
) | Load a Checkpoint or raise helpful errors. | Load a Checkpoint or raise helpful errors. | def load_checkpoint(
context: DataContext,
checkpoint_name: str,
usage_event: str,
) -> Union[Checkpoint, LegacyCheckpoint]:
"""Load a Checkpoint or raise helpful errors."""
try:
checkpoint: Union[Checkpoint, LegacyCheckpoint] = context.get_checkpoint(
name=checkpoint_name
... | [
"def",
"load_checkpoint",
"(",
"context",
":",
"DataContext",
",",
"checkpoint_name",
":",
"str",
",",
"usage_event",
":",
"str",
",",
")",
"->",
"Union",
"[",
"Checkpoint",
",",
"LegacyCheckpoint",
"]",
":",
"try",
":",
"checkpoint",
":",
"Union",
"[",
"C... | [
340,
0
] | [
362,
9
] | python | en | ['en', 'en', 'en'] | True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.