Datasets:

---

blindsubmissions

/

GH_text2code

like 4

[ "async", "def", "open_stream_to_socket_listener", "(", "socket_listener", ")", ":", "family", "=", "socket_listener", ".", "socket", ".", "family", "sockaddr", "=", "socket_listener", ".", "socket", ".", "getsockname", "(", ")", "if", "family", "in", "(", "tsocket", ".", "AF_INET", ",", "tsocket", ".", "AF_INET6", ")", ":", "sockaddr", "=", "list", "(", "sockaddr", ")", "if", "sockaddr", "[", "0", "]", "==", "\"0.0.0.0\"", ":", "sockaddr", "[", "0", "]", "=", "\"127.0.0.1\"", "if", "sockaddr", "[", "0", "]", "==", "\"::\"", ":", "sockaddr", "[", "0", "]", "=", "\"::1\"", "sockaddr", "=", "tuple", "(", "sockaddr", ")", "sock", "=", "tsocket", ".", "socket", "(", "family", "=", "family", ")", "await", "sock", ".", "connect", "(", "sockaddr", ")", "return", "SocketStream", "(", "sock", ")" ]

[ 4, 0 ]

[ 33, 29 ]

[ "def", "Compile", "(", "logger", ":", "logging", ".", "Logger", ",", "input_text", ":", "str", ",", "cache", ":", "Optional", "[", "Cache", "]", "=", "None", ",", "file_checker", ":", "Optional", "[", "IRFileChecker", "]", "=", "None", ",", "secret_handler", ":", "Optional", "[", "SecretHandler", "]", "=", "None", ",", "k8s", "=", "False", ",", "envoy_version", "=", "\"V2\"", ")", "->", "Dict", "[", "str", ",", "Union", "[", "IR", ",", "EnvoyConfig", "]", "]", ":", "if", "not", "file_checker", ":", "file_checker", "=", "lambda", "path", ":", "True", "if", "not", "secret_handler", ":", "secret_handler", "=", "NullSecretHandler", "(", "logger", ",", "None", ",", "None", ",", "\"fake\"", ")", "aconf", "=", "Config", "(", ")", "fetcher", "=", "ResourceFetcher", "(", "logger", ",", "aconf", ")", "if", "k8s", ":", "fetcher", ".", "parse_yaml", "(", "input_text", ",", "k8s", "=", "True", ")", "else", ":", "fetcher", ".", "parse_watt", "(", "input_text", ")", "aconf", ".", "load_all", "(", "fetcher", ".", "sorted", "(", ")", ")", "ir", "=", "IR", "(", "aconf", ",", "cache", "=", "cache", ",", "file_checker", "=", "file_checker", ",", "secret_handler", "=", "secret_handler", ")", "out", ":", "Dict", "[", "str", ",", "Union", "[", "IR", ",", "EnvoyConfig", "]", "]", "=", "{", "\"ir\"", ":", "ir", "}", "if", "ir", ":", "out", "[", "envoy_version", ".", "lower", "(", ")", "]", "=", "EnvoyConfig", ".", "generate", "(", "ir", ",", "envoy_version", ".", "upper", "(", ")", ",", "cache", "=", "cache", ")", "return", "out" ]

[ 26, 0 ]

[ 74, 14 ]

[ "def", "simple_tmle", "(", "y", ",", "w", ",", "q0w", ",", "q1w", ",", "p", ",", "alpha", "=", "0.0001", ")", ":", "scaler", "=", "MinMaxScaler", "(", ")", "ystar", "=", "scaler", ".", "fit_transform", "(", "y", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", "q0", "=", "np", ".", "clip", "(", "scaler", ".", "transform", "(", "q0w", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", ",", "alpha", ",", "1", "-", "alpha", ")", "q1", "=", "np", ".", "clip", "(", "scaler", ".", "transform", "(", "q1w", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", ",", "alpha", ",", "1", "-", "alpha", ")", "qaw", "=", "q0", "*", "(", "1", "-", "w", ")", "+", "q1", "*", "w", "intercept", "=", "logit", "(", "qaw", ")", "h1", "=", "w", "/", "p", "h0", "=", "(", "1", "-", "w", ")", "/", "(", "1", "-", "p", ")", "sol", "=", "minimize", "(", "logit_tmle", ",", "np", ".", "zeros", "(", "2", ")", ",", "args", "=", "(", "ystar", ",", "intercept", ",", "h0", ",", "h1", ")", ",", "method", "=", "\"Newton-CG\"", ",", "jac", "=", "logit_tmle_grad", ",", "hess", "=", "logit_tmle_hess", ")", "qawstar", "=", "scaler", ".", "inverse_transform", "(", "expit", "(", "intercept", "+", "sol", ".", "x", "[", "0", "]", "*", "h0", "+", "sol", ".", "x", "[", "1", "]", "*", "h1", ")", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", "q0star", "=", "scaler", ".", "inverse_transform", "(", "expit", "(", "logit", "(", "q0", ")", "+", "sol", ".", "x", "[", "0", "]", "/", "(", "1", "-", "p", ")", ")", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", "q1star", "=", "scaler", ".", "inverse_transform", "(", "expit", "(", "logit", "(", "q1", ")", "+", "sol", ".", "x", "[", "1", "]", "/", "p", ")", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "flatten", "(", ")", "ic", "=", "(", "w", "/", "p", "-", "(", "1", "-", "w", ")", "/", "(", "1", "-", "p", ")", ")", "*", "(", "y", "-", "qawstar", ")", "+", "q1star", "-", "q0star", "-", "np", ".", "mean", "(", "q1star", "-", "q0star", ")", "return", "np", ".", "mean", "(", "q1star", "-", "q0star", ")", ",", "np", ".", "sqrt", "(", "np", ".", "var", "(", "ic", ")", "/", "np", ".", "size", "(", "y", ")", ")" ]

[ 31, 0 ]

[ 67, 69 ]

[ "def", "__init__", "(", "self", ",", "learner", ",", "ate_alpha", "=", ".05", ",", "control_name", "=", "0", ",", "cv", "=", "None", ",", "calibrate_propensity", "=", "True", ")", ":", "self", ".", "model_tau", "=", "learner", "self", ".", "ate_alpha", "=", "ate_alpha", "self", ".", "control_name", "=", "control_name", "self", ".", "cv", "=", "cv", "self", ".", "calibrate_propensity", "=", "calibrate_propensity" ]

[ 76, 4 ]

[ 89, 56 ]

[ "def", "estimate_ate", "(", "self", ",", "X", ",", "treatment", ",", "y", ",", "p", ",", "segment", "=", "None", ",", "return_ci", "=", "False", ")", ":", "X", ",", "treatment", ",", "y", "=", "convert_pd_to_np", "(", "X", ",", "treatment", ",", "y", ")", "check_treatment_vector", "(", "treatment", ",", "self", ".", "control_name", ")", "self", ".", "t_groups", "=", "np", ".", "unique", "(", "treatment", "[", "treatment", "!=", "self", ".", "control_name", "]", ")", "self", ".", "t_groups", ".", "sort", "(", ")", "check_p_conditions", "(", "p", ",", "self", ".", "t_groups", ")", "if", "isinstance", "(", "p", ",", "(", "np", ".", "ndarray", ",", "pd", ".", "Series", ")", ")", ":", "treatment_name", "=", "self", ".", "t_groups", "[", "0", "]", "p", "=", "{", "treatment_name", ":", "convert_pd_to_np", "(", "p", ")", "}", "elif", "isinstance", "(", "p", ",", "dict", ")", ":", "p", "=", "{", "treatment_name", ":", "convert_pd_to_np", "(", "_p", ")", "for", "treatment_name", ",", "_p", "in", "p", ".", "items", "(", ")", "}", "ate", "=", "[", "]", "ate_lb", "=", "[", "]", "ate_ub", "=", "[", "]", "for", "i", ",", "group", "in", "enumerate", "(", "self", ".", "t_groups", ")", ":", "logger", ".", "info", "(", "'Estimating ATE for group {}.'", ".", "format", "(", "group", ")", ")", "w_group", "=", "(", "treatment", "==", "group", ")", ".", "astype", "(", "int", ")", "p_group", "=", "p", "[", "group", "]", "if", "self", ".", "calibrate_propensity", ":", "logger", ".", "info", "(", "'Calibrating propensity scores.'", ")", "p_group", "=", "calibrate", "(", "p_group", ",", "w_group", ")", "yhat_c", "=", "np", ".", "zeros_like", "(", "y", ",", "dtype", "=", "float", ")", "yhat_t", "=", "np", ".", "zeros_like", "(", "y", ",", "dtype", "=", "float", ")", "if", "self", ".", "cv", ":", "for", "i_fold", ",", "(", "i_trn", ",", "i_val", ")", "in", "enumerate", "(", "self", ".", "cv", ".", "split", "(", "X", ",", "y", ")", ",", "1", ")", ":", "logger", ".", "info", "(", "'Training an outcome model for CV #{}'", ".", "format", "(", "i_fold", ")", ")", "self", ".", "model_tau", ".", "fit", "(", "np", ".", "hstack", "(", "(", "X", "[", "i_trn", "]", ",", "w_group", "[", "i_trn", "]", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ")", ",", "y", "[", "i_trn", "]", ")", "yhat_c", "[", "i_val", "]", "=", "self", ".", "model_tau", ".", "predict", "(", "np", ".", "hstack", "(", "(", "X", "[", "i_val", "]", ",", "np", ".", "zeros", "(", "(", "len", "(", "i_val", ")", ",", "1", ")", ")", ")", ")", ")", "yhat_t", "[", "i_val", "]", "=", "self", ".", "model_tau", ".", "predict", "(", "np", ".", "hstack", "(", "(", "X", "[", "i_val", "]", ",", "np", ".", "ones", "(", "(", "len", "(", "i_val", ")", ",", "1", ")", ")", ")", ")", ")", "else", ":", "self", ".", "model_tau", ".", "fit", "(", "np", ".", "hstack", "(", "(", "X", ",", "w_group", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ")", ",", "y", ")", "yhat_c", "=", "self", ".", "model_tau", ".", "predict", "(", "np", ".", "hstack", "(", "(", "X", ",", "np", ".", "zeros", "(", "(", "len", "(", "y", ")", ",", "1", ")", ")", ")", ")", ")", "yhat_t", "=", "self", ".", "model_tau", ".", "predict", "(", "np", ".", "hstack", "(", "(", "X", ",", "np", ".", "ones", "(", "(", "len", "(", "y", ")", ",", "1", ")", ")", ")", ")", ")", "if", "segment", "is", "None", ":", "logger", ".", "info", "(", "'Training the TMLE learner.'", ")", "_ate", ",", "se", "=", "simple_tmle", "(", "y", ",", "w_group", ",", "yhat_c", ",", "yhat_t", ",", "p_group", ")", "_ate_lb", "=", "_ate", "-", "se", "*", "norm", ".", "ppf", "(", "1", "-", "self", ".", "ate_alpha", "/", "2", ")", "_ate_ub", "=", "_ate", "+", "se", "*", "norm", ".", "ppf", "(", "1", "-", "self", ".", "ate_alpha", "/", "2", ")", "else", ":", "assert", "segment", ".", "shape", "[", "0", "]", "==", "X", ".", "shape", "[", "0", "]", "and", "segment", ".", "ndim", "==", "1", ",", "'Segment must be the 1-d np.array of int.'", "segments", "=", "np", ".", "unique", "(", "segment", ")", "_ate", "=", "[", "]", "_ate_lb", "=", "[", "]", "_ate_ub", "=", "[", "]", "for", "s", "in", "sorted", "(", "segments", ")", ":", "logger", ".", "info", "(", "'Training the TMLE learner for segment {}.'", ".", "format", "(", "s", ")", ")", "filt", "=", "(", "segment", "==", "s", ")", "&", "(", "yhat_c", "<", "np", ".", "quantile", "(", "yhat_c", ",", "q", "=", ".99", ")", ")", "_ate_s", ",", "se", "=", "simple_tmle", "(", "y", "[", "filt", "]", ",", "w_group", "[", "filt", "]", ",", "yhat_c", "[", "filt", "]", ",", "yhat_t", "[", "filt", "]", ",", "p_group", "[", "filt", "]", ")", "_ate_lb_s", "=", "_ate_s", "-", "se", "*", "norm", ".", "ppf", "(", "1", "-", "self", ".", "ate_alpha", "/", "2", ")", "_ate_ub_s", "=", "_ate_s", "+", "se", "*", "norm", ".", "ppf", "(", "1", "-", "self", ".", "ate_alpha", "/", "2", ")", "_ate", ".", "append", "(", "_ate_s", ")", "_ate_lb", ".", "append", "(", "_ate_lb_s", ")", "_ate_ub", ".", "append", "(", "_ate_ub_s", ")", "ate", ".", "append", "(", "_ate", ")", "ate_lb", ".", "append", "(", "_ate_lb", ")", "ate_ub", ".", "append", "(", "_ate_ub", ")", "return", "np", ".", "array", "(", "ate", ")", ",", "np", ".", "array", "(", "ate_lb", ")", ",", "np", ".", "array", "(", "ate_ub", ")" ]

[ 94, 4 ]

[ 178, 64 ]

[ "def", "fit", "(", "self", ",", "X", ",", "treatment", ",", "y", ")", ":", "assert", "len", "(", "X", ")", "==", "len", "(", "y", ")", "and", "len", "(", "X", ")", "==", "len", "(", "treatment", ")", ",", "'Data length must be equal for X, treatment, and y.'", "self", ".", "treatment_group", "=", "list", "(", "set", "(", "treatment", ")", ")", "self", ".", "feature_imp_dict", "=", "defaultdict", "(", "float", ")", "if", "self", ".", "evaluationFunction", "==", "self", ".", "evaluate_DDP", "and", "len", "(", "self", ".", "treatment_group", ")", ">", "2", ":", "raise", "ValueError", "(", "\"The DDP approach can only cope with two class problems, that is two different treatment options (e.g., control vs treatment).\"", "\"Please select another approach or only use a data set which employs two treatment options.\"", ")", "self", ".", "fitted_uplift_tree", "=", "self", ".", "growDecisionTreeFrom", "(", "X", ",", "treatment", ",", "y", ",", "evaluationFunction", "=", "self", ".", "evaluationFunction", ",", "max_depth", "=", "self", ".", "max_depth", ",", "min_samples_leaf", "=", "self", ".", "min_samples_leaf", ",", "depth", "=", "1", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "self", ".", "n_reg", ",", "parentNodeSummary", "=", "None", ")", "self", ".", "feature_importances_", "=", "np", ".", "zeros", "(", "X", ".", "shape", "[", "1", "]", ")", "for", "col", ",", "imp", "in", "self", ".", "feature_imp_dict", ".", "items", "(", ")", ":", "self", ".", "feature_importances_", "[", "col", "]", "=", "imp", "self", ".", "feature_importances_", "/=", "self", ".", "feature_importances_", ".", "sum", "(", ")" ]

[ 166, 4 ]

[ 203, 68 ]

[ "def", "prune", "(", "self", ",", "X", ",", "treatment", ",", "y", ",", "minGain", "=", "0.0001", ",", "rule", "=", "'maxAbsDiff'", ")", ":", "assert", "len", "(", "X", ")", "==", "len", "(", "y", ")", "and", "len", "(", "X", ")", "==", "len", "(", "treatment", ")", ",", "'Data length must be equal for X, treatment, and y.'", "self", ".", "pruneTree", "(", "X", ",", "treatment", ",", "y", ",", "tree", "=", "self", ".", "fitted_uplift_tree", ",", "rule", "=", "rule", ",", "minGain", "=", "minGain", ",", "evaluationFunction", "=", "self", ".", "evaluationFunction", ",", "notify", "=", "False", ",", "n_reg", "=", "self", ".", "n_reg", ",", "parentNodeSummary", "=", "None", ")", "return", "self" ]

[ 206, 4 ]

[ 238, 19 ]

[ "def", "pruneTree", "(", "self", ",", "X", ",", "treatment", ",", "y", ",", "tree", ",", "rule", "=", "'maxAbsDiff'", ",", "minGain", "=", "0.", ",", "evaluationFunction", "=", "None", ",", "notify", "=", "False", ",", "n_reg", "=", "0", ",", "parentNodeSummary", "=", "None", ")", ":", "# Current Node Summary for Validation Data Set", "currentNodeSummary", "=", "self", ".", "tree_node_summary", "(", "treatment", ",", "y", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "parentNodeSummary", ")", "tree", ".", "nodeSummary", "=", "currentNodeSummary", "# Divide sets for child nodes", "X_l", ",", "X_r", ",", "w_l", ",", "w_r", ",", "y_l", ",", "y_r", "=", "self", ".", "divideSet", "(", "X", ",", "treatment", ",", "y", ",", "tree", ".", "col", ",", "tree", ".", "value", ")", "# recursive call for each branch", "if", "tree", ".", "trueBranch", ".", "results", "is", "None", ":", "self", ".", "pruneTree", "(", "X_l", ",", "w_l", ",", "y_l", ",", "tree", ".", "trueBranch", ",", "rule", ",", "minGain", ",", "evaluationFunction", ",", "notify", ",", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "if", "tree", ".", "falseBranch", ".", "results", "is", "None", ":", "self", ".", "pruneTree", "(", "X_r", ",", "w_r", ",", "y_r", ",", "tree", ".", "falseBranch", ",", "rule", ",", "minGain", ",", "evaluationFunction", ",", "notify", ",", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "# merge leaves (potentially)", "if", "(", "tree", ".", "trueBranch", ".", "results", "is", "not", "None", "and", "tree", ".", "falseBranch", ".", "results", "is", "not", "None", ")", ":", "if", "rule", "==", "'maxAbsDiff'", ":", "# Current D", "if", "(", "tree", ".", "maxDiffTreatment", "in", "currentNodeSummary", "and", "self", ".", "control_name", "in", "currentNodeSummary", ")", ":", "currentScoreD", "=", "tree", ".", "maxDiffSign", "*", "(", "currentNodeSummary", "[", "tree", ".", "maxDiffTreatment", "]", "[", "0", "]", "-", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "else", ":", "currentScoreD", "=", "0", "# trueBranch D", "trueNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_l", ",", "y_l", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "if", "(", "tree", ".", "trueBranch", ".", "maxDiffTreatment", "in", "trueNodeSummary", "and", "self", ".", "control_name", "in", "trueNodeSummary", ")", ":", "trueScoreD", "=", "tree", ".", "trueBranch", ".", "maxDiffSign", "*", "(", "trueNodeSummary", "[", "tree", ".", "trueBranch", ".", "maxDiffTreatment", "]", "[", "0", "]", "-", "trueNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "trueScoreD", "=", "(", "trueScoreD", "*", "(", "trueNodeSummary", "[", "tree", ".", "trueBranch", ".", "maxDiffTreatment", "]", "[", "1", "]", "+", "trueNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", ")", "/", "(", "currentNodeSummary", "[", "tree", ".", "trueBranch", ".", "maxDiffTreatment", "]", "[", "1", "]", "+", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", ")", ")", "else", ":", "trueScoreD", "=", "0", "# falseBranch D", "falseNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_r", ",", "y_r", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "if", "(", "tree", ".", "falseBranch", ".", "maxDiffTreatment", "in", "falseNodeSummary", "and", "self", ".", "control_name", "in", "falseNodeSummary", ")", ":", "falseScoreD", "=", "(", "tree", ".", "falseBranch", ".", "maxDiffSign", "*", "(", "falseNodeSummary", "[", "tree", ".", "falseBranch", ".", "maxDiffTreatment", "]", "[", "0", "]", "-", "falseNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", ")", "falseScoreD", "=", "(", "falseScoreD", "*", "(", "falseNodeSummary", "[", "tree", ".", "falseBranch", ".", "maxDiffTreatment", "]", "[", "1", "]", "+", "falseNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", ")", "/", "(", "currentNodeSummary", "[", "tree", ".", "falseBranch", ".", "maxDiffTreatment", "]", "[", "1", "]", "+", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", ")", ")", "else", ":", "falseScoreD", "=", "0", "if", "(", "(", "trueScoreD", "+", "falseScoreD", ")", "-", "currentScoreD", "<=", "minGain", "or", "(", "trueScoreD", "+", "falseScoreD", "<", "0.", ")", ")", ":", "tree", ".", "trueBranch", ",", "tree", ".", "falseBranch", "=", "None", ",", "None", "tree", ".", "results", "=", "tree", ".", "backupResults", "elif", "rule", "==", "'bestUplift'", ":", "# Current D", "if", "(", "tree", ".", "bestTreatment", "in", "currentNodeSummary", "and", "self", ".", "control_name", "in", "currentNodeSummary", ")", ":", "currentScoreD", "=", "(", "currentNodeSummary", "[", "tree", ".", "bestTreatment", "]", "[", "0", "]", "-", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "else", ":", "currentScoreD", "=", "0", "# trueBranch D", "trueNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_l", ",", "y_l", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "if", "(", "tree", ".", "trueBranch", ".", "bestTreatment", "in", "trueNodeSummary", "and", "self", ".", "control_name", "in", "trueNodeSummary", ")", ":", "trueScoreD", "=", "(", "trueNodeSummary", "[", "tree", ".", "trueBranch", ".", "bestTreatment", "]", "[", "0", "]", "-", "trueNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "else", ":", "trueScoreD", "=", "0", "# falseBranch D", "falseNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_r", ",", "y_r", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "if", "(", "tree", ".", "falseBranch", ".", "bestTreatment", "in", "falseNodeSummary", "and", "self", ".", "control_name", "in", "falseNodeSummary", ")", ":", "falseScoreD", "=", "(", "falseNodeSummary", "[", "tree", ".", "falseBranch", ".", "bestTreatment", "]", "[", "0", "]", "-", "falseNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "else", ":", "falseScoreD", "=", "0", "gain", "=", "(", "(", "1.", "*", "len", "(", "y_l", ")", "/", "len", "(", "y", ")", "*", "trueScoreD", "+", "1.", "*", "len", "(", "y_r", ")", "/", "len", "(", "y", ")", "*", "falseScoreD", ")", "-", "currentScoreD", ")", "if", "gain", "<=", "minGain", "or", "(", "trueScoreD", "+", "falseScoreD", "<", "0.", ")", ":", "tree", ".", "trueBranch", ",", "tree", ".", "falseBranch", "=", "None", ",", "None", "tree", ".", "results", "=", "tree", ".", "backupResults", "return", "self" ]

[ 240, 4 ]

[ 392, 19 ]

[ "def", "fill", "(", "self", ",", "X", ",", "treatment", ",", "y", ")", ":", "assert", "len", "(", "X", ")", "==", "len", "(", "y", ")", "and", "len", "(", "X", ")", "==", "len", "(", "treatment", ")", ",", "'Data length must be equal for X, treatment, and y.'", "self", ".", "fillTree", "(", "X", ",", "treatment", ",", "y", ",", "tree", "=", "self", ".", "fitted_uplift_tree", ")", "return", "self" ]

[ 394, 4 ]

[ 415, 19 ]

[ "def", "fillTree", "(", "self", ",", "X", ",", "treatment", ",", "y", ",", "tree", ")", ":", "# Current Node Summary for Validation Data Set", "currentNodeSummary", "=", "self", ".", "tree_node_summary", "(", "treatment", ",", "y", ",", "min_samples_treatment", "=", "0", ",", "n_reg", "=", "0", ",", "parentNodeSummary", "=", "None", ")", "tree", ".", "nodeSummary", "=", "currentNodeSummary", "# Divide sets for child nodes", "X_l", ",", "X_r", ",", "w_l", ",", "w_r", ",", "y_l", ",", "y_r", "=", "self", ".", "divideSet", "(", "X", ",", "treatment", ",", "y", ",", "tree", ".", "col", ",", "tree", ".", "value", ")", "# recursive call for each branch", "if", "tree", ".", "trueBranch", "is", "not", "None", ":", "self", ".", "fillTree", "(", "X_l", ",", "w_l", ",", "y_l", ",", "tree", ".", "trueBranch", ")", "if", "tree", ".", "falseBranch", "is", "not", "None", ":", "self", ".", "fillTree", "(", "X_r", ",", "w_r", ",", "y_r", ",", "tree", ".", "falseBranch", ")", "# Update Information", "# matchScore", "matchScore", "=", "(", "currentNodeSummary", "[", "tree", ".", "bestTreatment", "]", "[", "0", "]", "-", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "tree", ".", "matchScore", "=", "round", "(", "matchScore", ",", "4", ")", "tree", ".", "summary", "[", "'matchScore'", "]", "=", "round", "(", "matchScore", ",", "4", ")", "# Samples, Group_size", "tree", ".", "summary", "[", "'samples'", "]", "=", "len", "(", "y", ")", "tree", ".", "summary", "[", "'group_size'", "]", "=", "''", "for", "treatment_group", "in", "currentNodeSummary", ":", "tree", ".", "summary", "[", "'group_size'", "]", "+=", "' '", "+", "treatment_group", "+", "': '", "+", "str", "(", "currentNodeSummary", "[", "treatment_group", "]", "[", "1", "]", ")", "# classProb", "if", "tree", ".", "results", "is", "not", "None", ":", "tree", ".", "results", "=", "self", ".", "uplift_classification_results", "(", "treatment", ",", "y", ")", "return", "self" ]

[ 417, 4 ]

[ 466, 19 ]

[ "def", "predict", "(", "self", ",", "X", ",", "full_output", "=", "False", ")", ":", "p_hat_optimal", "=", "[", "]", "treatment_optimal", "=", "[", "]", "pred_nodes", "=", "{", "}", "upliftScores", "=", "[", "]", "for", "xi", "in", "range", "(", "len", "(", "X", ")", ")", ":", "pred_leaf", ",", "upliftScore", "=", "self", ".", "classify", "(", "X", "[", "xi", "]", ",", "self", ".", "fitted_uplift_tree", ",", "dataMissing", "=", "False", ")", "# Predict under uplift optimal treatment", "opt_treat", "=", "max", "(", "pred_leaf", ",", "key", "=", "pred_leaf", ".", "get", ")", "p_hat_optimal", ".", "append", "(", "pred_leaf", "[", "opt_treat", "]", ")", "treatment_optimal", ".", "append", "(", "opt_treat", ")", "if", "full_output", ":", "if", "xi", "==", "0", ":", "for", "key_i", "in", "pred_leaf", ":", "pred_nodes", "[", "key_i", "]", "=", "[", "pred_leaf", "[", "key_i", "]", "]", "else", ":", "for", "key_i", "in", "pred_leaf", ":", "pred_nodes", "[", "key_i", "]", ".", "append", "(", "pred_leaf", "[", "key_i", "]", ")", "upliftScores", ".", "append", "(", "upliftScore", ")", "if", "full_output", ":", "return", "treatment_optimal", ",", "p_hat_optimal", ",", "upliftScores", ",", "pred_nodes", "else", ":", "return", "treatment_optimal", ",", "p_hat_optimal" ]

[ 468, 4 ]

[ 511, 51 ]

[ "def", "divideSet", "(", "X", ",", "treatment", ",", "y", ",", "column", ",", "value", ")", ":", "# for int and float values", "if", "isinstance", "(", "value", ",", "int", ")", "or", "isinstance", "(", "value", ",", "float", ")", ":", "filt", "=", "X", "[", ":", ",", "column", "]", ">=", "value", "else", ":", "# for strings", "filt", "=", "X", "[", ":", ",", "column", "]", "==", "value", "return", "X", "[", "filt", "]", ",", "X", "[", "~", "filt", "]", ",", "treatment", "[", "filt", "]", ",", "treatment", "[", "~", "filt", "]", ",", "y", "[", "filt", "]", ",", "y", "[", "~", "filt", "]" ]

[ 514, 4 ]

[ 542, 86 ]

[ "def", "group_uniqueCounts", "(", "self", ",", "treatment", ",", "y", ")", ":", "results", "=", "{", "}", "for", "t", "in", "self", ".", "treatment_group", ":", "filt", "=", "treatment", "==", "t", "n_t", "=", "y", "[", "filt", "]", ".", "sum", "(", ")", "results", "[", "t", "]", "=", "(", "filt", ".", "sum", "(", ")", "-", "n_t", ",", "n_t", ")", "return", "results" ]

[ 544, 4 ]

[ 566, 22 ]

[ "def", "kl_divergence", "(", "pk", ",", "qk", ")", ":", "eps", "=", "1e-6", "qk", "=", "np", ".", "clip", "(", "qk", ",", "eps", ",", "1", "-", "eps", ")", "if", "pk", "==", "0", ":", "S", "=", "-", "np", ".", "log", "(", "1", "-", "qk", ")", "elif", "pk", "==", "1", ":", "S", "=", "-", "np", ".", "log", "(", "qk", ")", "else", ":", "S", "=", "pk", "*", "np", ".", "log", "(", "pk", "/", "qk", ")", "+", "(", "1", "-", "pk", ")", "*", "np", ".", "log", "(", "(", "1", "-", "pk", ")", "/", "(", "1", "-", "qk", ")", ")", "return", "S" ]

[ 569, 4 ]

[ 598, 16 ]

[ "def", "evaluate_KL", "(", "self", ",", "nodeSummary", ",", "control_name", ")", ":", "if", "control_name", "not", "in", "nodeSummary", ":", "return", "0", "pc", "=", "nodeSummary", "[", "control_name", "]", "[", "0", "]", "d_res", "=", "0", "for", "treatment_group", "in", "nodeSummary", ":", "if", "treatment_group", "!=", "control_name", ":", "d_res", "+=", "self", ".", "kl_divergence", "(", "nodeSummary", "[", "treatment_group", "]", "[", "0", "]", ",", "pc", ")", "return", "d_res" ]

[ 600, 4 ]

[ 624, 20 ]

[ "def", "evaluate_ED", "(", "nodeSummary", ",", "control_name", ")", ":", "if", "control_name", "not", "in", "nodeSummary", ":", "return", "0", "pc", "=", "nodeSummary", "[", "control_name", "]", "[", "0", "]", "d_res", "=", "0", "for", "treatment_group", "in", "nodeSummary", ":", "if", "treatment_group", "!=", "control_name", ":", "d_res", "+=", "2", "*", "(", "nodeSummary", "[", "treatment_group", "]", "[", "0", "]", "-", "pc", ")", "**", "2", "return", "d_res" ]

[ 627, 4 ]

[ 651, 20 ]

[ "def", "evaluate_Chi", "(", "nodeSummary", ",", "control_name", ")", ":", "if", "control_name", "not", "in", "nodeSummary", ":", "return", "0", "pc", "=", "nodeSummary", "[", "control_name", "]", "[", "0", "]", "d_res", "=", "0", "for", "treatment_group", "in", "nodeSummary", ":", "if", "treatment_group", "!=", "control_name", ":", "d_res", "+=", "(", "(", "nodeSummary", "[", "treatment_group", "]", "[", "0", "]", "-", "pc", ")", "**", "2", "/", "max", "(", "0.1", "**", "6", ",", "pc", ")", "+", "(", "nodeSummary", "[", "treatment_group", "]", "[", "0", "]", "-", "pc", ")", "**", "2", "/", "max", "(", "0.1", "**", "6", ",", "1", "-", "pc", ")", ")", "return", "d_res" ]

[ 654, 4 ]

[ 678, 20 ]

[ "def", "evaluate_DDP", "(", "nodeSummary", ",", "control_name", ")", ":", "if", "control_name", "not", "in", "nodeSummary", ":", "return", "0", "pc", "=", "nodeSummary", "[", "control_name", "]", "[", "0", "]", "d_res", "=", "0", "for", "treatment_group", "in", "nodeSummary", ":", "if", "treatment_group", "!=", "control_name", ":", "d_res", "+=", "nodeSummary", "[", "treatment_group", "]", "[", "0", "]", "-", "pc", "return", "d_res" ]

[ 681, 4 ]

[ 704, 20 ]

[ "def", "evaluate_CTS", "(", "currentNodeSummary", ")", ":", "mu", "=", "0.0", "# iterate treatment group", "for", "r", "in", "currentNodeSummary", ":", "mu", "=", "max", "(", "mu", ",", "currentNodeSummary", "[", "r", "]", "[", "0", "]", ")", "return", "-", "mu" ]

[ 707, 4 ]

[ 727, 18 ]

[ "def", "entropyH", "(", "p", ",", "q", "=", "None", ")", ":", "if", "q", "is", "None", "and", "p", ">", "0", ":", "return", "-", "p", "*", "np", ".", "log", "(", "p", ")", "elif", "q", ">", "0", ":", "return", "-", "p", "*", "np", ".", "log", "(", "q", ")", "else", ":", "return", "0" ]

[ 730, 4 ]

[ 753, 20 ]

[ "def", "normI", "(", "self", ",", "currentNodeSummary", ",", "leftNodeSummary", ",", "rightNodeSummary", ",", "control_name", ",", "alpha", "=", "0.9", ")", ":", "norm_res", "=", "0", "# n_t, n_c: sample size for all treatment, and control", "# pt_a, pc_a: % of treatment is in left node, % of control is in left node", "n_c", "=", "currentNodeSummary", "[", "control_name", "]", "[", "1", "]", "n_c_left", "=", "leftNodeSummary", "[", "control_name", "]", "[", "1", "]", "n_t", "=", "[", "]", "n_t_left", "=", "[", "]", "for", "treatment_group", "in", "currentNodeSummary", ":", "if", "treatment_group", "!=", "control_name", ":", "n_t", ".", "append", "(", "currentNodeSummary", "[", "treatment_group", "]", "[", "1", "]", ")", "if", "treatment_group", "in", "leftNodeSummary", ":", "n_t_left", ".", "append", "(", "leftNodeSummary", "[", "treatment_group", "]", "[", "1", "]", ")", "else", ":", "n_t_left", ".", "append", "(", "0", ")", "pt_a", "=", "1.", "*", "np", ".", "sum", "(", "n_t_left", ")", "/", "(", "np", ".", "sum", "(", "n_t", ")", "+", "0.1", ")", "pc_a", "=", "1.", "*", "n_c_left", "/", "(", "n_c", "+", "0.1", ")", "# Normalization Part 1", "norm_res", "+=", "(", "alpha", "*", "self", ".", "entropyH", "(", "1.", "*", "np", ".", "sum", "(", "n_t", ")", "/", "(", "np", ".", "sum", "(", "n_t", ")", "+", "n_c", ")", ",", "1.", "*", "n_c", "/", "(", "np", ".", "sum", "(", "n_t", ")", "+", "n_c", ")", ")", "*", "self", ".", "kl_divergence", "(", "pt_a", ",", "pc_a", ")", ")", "# Normalization Part 2 & 3", "for", "i", "in", "range", "(", "len", "(", "n_t", ")", ")", ":", "pt_a_i", "=", "1.", "*", "n_t_left", "[", "i", "]", "/", "(", "n_t", "[", "i", "]", "+", "0.1", ")", "norm_res", "+=", "(", "(", "1", "-", "alpha", ")", "*", "self", ".", "entropyH", "(", "1.", "*", "n_t", "[", "i", "]", "/", "(", "n_t", "[", "i", "]", "+", "n_c", ")", ",", "1.", "*", "n_c", "/", "(", "n_t", "[", "i", "]", "+", "n_c", ")", ")", "*", "self", ".", "kl_divergence", "(", "1.", "*", "pt_a_i", ",", "pc_a", ")", ")", "norm_res", "+=", "(", "1.", "*", "n_t", "[", "i", "]", "/", "(", "np", ".", "sum", "(", "n_t", ")", "+", "n_c", ")", "*", "self", ".", "entropyH", "(", "pt_a_i", ")", ")", "# Normalization Part 4", "norm_res", "+=", "1.", "*", "n_c", "/", "(", "np", ".", "sum", "(", "n_t", ")", "+", "n_c", ")", "*", "self", ".", "entropyH", "(", "pc_a", ")", "# Normalization Part 5", "norm_res", "+=", "0.5", "return", "norm_res" ]

[ 755, 4 ]

[ 815, 23 ]

[ "def", "tree_node_summary", "(", "self", ",", "treatment", ",", "y", ",", "min_samples_treatment", "=", "10", ",", "n_reg", "=", "100", ",", "parentNodeSummary", "=", "None", ")", ":", "# returns {treatment_group: p(1)}", "results", "=", "self", ".", "group_uniqueCounts", "(", "treatment", ",", "y", ")", "# node Summary: {treatment_group: [p(1), size]}", "nodeSummary", "=", "{", "}", "# iterate treatment group", "for", "r", "in", "results", ":", "n1", "=", "results", "[", "r", "]", "[", "1", "]", "ntot", "=", "results", "[", "r", "]", "[", "0", "]", "+", "n1", "if", "parentNodeSummary", "is", "None", ":", "y_mean", "=", "n1", "/", "ntot", "elif", "ntot", ">", "min_samples_treatment", ":", "y_mean", "=", "(", "n1", "+", "parentNodeSummary", "[", "r", "]", "[", "0", "]", "*", "n_reg", ")", "/", "(", "ntot", "+", "n_reg", ")", "else", ":", "y_mean", "=", "parentNodeSummary", "[", "r", "]", "[", "0", "]", "nodeSummary", "[", "r", "]", "=", "[", "y_mean", ",", "ntot", "]", "return", "nodeSummary" ]

[ 817, 4 ]

[ 858, 26 ]

[ "def", "uplift_classification_results", "(", "self", ",", "treatment", ",", "y", ")", ":", "results", "=", "self", ".", "group_uniqueCounts", "(", "treatment", ",", "y", ")", "res", "=", "{", "}", "for", "r", "in", "results", ":", "p", "=", "float", "(", "results", "[", "r", "]", "[", "1", "]", ")", "/", "(", "results", "[", "r", "]", "[", "0", "]", "+", "results", "[", "r", "]", "[", "1", "]", ")", "res", "[", "r", "]", "=", "round", "(", "p", ",", "6", ")", "return", "res" ]

[ 860, 4 ]

[ 881, 18 ]

[ "def", "growDecisionTreeFrom", "(", "self", ",", "X", ",", "treatment", ",", "y", ",", "evaluationFunction", ",", "max_depth", "=", "10", ",", "min_samples_leaf", "=", "100", ",", "depth", "=", "1", ",", "min_samples_treatment", "=", "10", ",", "n_reg", "=", "100", ",", "parentNodeSummary", "=", "None", ")", ":", "if", "len", "(", "X", ")", "==", "0", ":", "return", "DecisionTree", "(", ")", "# Current Node Info and Summary", "currentNodeSummary", "=", "self", ".", "tree_node_summary", "(", "treatment", ",", "y", ",", "min_samples_treatment", "=", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "parentNodeSummary", ")", "if", "evaluationFunction", "==", "self", ".", "evaluate_CTS", ":", "currentScore", "=", "evaluationFunction", "(", "currentNodeSummary", ")", "else", ":", "currentScore", "=", "evaluationFunction", "(", "currentNodeSummary", ",", "control_name", "=", "self", ".", "control_name", ")", "# Prune Stats", "maxAbsDiff", "=", "0", "maxDiff", "=", "-", "1.", "bestTreatment", "=", "self", ".", "control_name", "suboptTreatment", "=", "self", ".", "control_name", "maxDiffTreatment", "=", "self", ".", "control_name", "maxDiffSign", "=", "0", "for", "treatment_group", "in", "currentNodeSummary", ":", "if", "treatment_group", "!=", "self", ".", "control_name", ":", "diff", "=", "(", "currentNodeSummary", "[", "treatment_group", "]", "[", "0", "]", "-", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", ")", "if", "abs", "(", "diff", ")", ">=", "maxAbsDiff", ":", "maxDiffTreatment", "=", "treatment_group", "maxDiffSign", "=", "np", ".", "sign", "(", "diff", ")", "maxAbsDiff", "=", "abs", "(", "diff", ")", "if", "diff", ">=", "maxDiff", ":", "maxDiff", "=", "diff", "suboptTreatment", "=", "treatment_group", "if", "diff", ">", "0", ":", "bestTreatment", "=", "treatment_group", "if", "maxDiff", ">", "0", ":", "pt", "=", "currentNodeSummary", "[", "bestTreatment", "]", "[", "0", "]", "nt", "=", "currentNodeSummary", "[", "bestTreatment", "]", "[", "1", "]", "pc", "=", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", "nc", "=", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", "p_value", "=", "(", "1.", "-", "stats", ".", "norm", ".", "cdf", "(", "(", "pt", "-", "pc", ")", "/", "np", ".", "sqrt", "(", "pt", "*", "(", "1", "-", "pt", ")", "/", "nt", "+", "pc", "*", "(", "1", "-", "pc", ")", "/", "nc", ")", ")", ")", "*", "2", "else", ":", "pt", "=", "currentNodeSummary", "[", "suboptTreatment", "]", "[", "0", "]", "nt", "=", "currentNodeSummary", "[", "suboptTreatment", "]", "[", "1", "]", "pc", "=", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "0", "]", "nc", "=", "currentNodeSummary", "[", "self", ".", "control_name", "]", "[", "1", "]", "p_value", "=", "(", "1.", "-", "stats", ".", "norm", ".", "cdf", "(", "(", "pc", "-", "pt", ")", "/", "np", ".", "sqrt", "(", "pt", "*", "(", "1", "-", "pt", ")", "/", "nt", "+", "pc", "*", "(", "1", "-", "pc", ")", "/", "nc", ")", ")", ")", "*", "2", "upliftScore", "=", "[", "maxDiff", ",", "p_value", "]", "bestGain", "=", "0.0", "bestAttribute", "=", "None", "# last column is the result/target column, 2nd to the last is the treatment group", "columnCount", "=", "X", ".", "shape", "[", "1", "]", "if", "(", "self", ".", "max_features", "and", "self", ".", "max_features", ">", "0", "and", "self", ".", "max_features", "<=", "columnCount", ")", ":", "max_features", "=", "self", ".", "max_features", "else", ":", "max_features", "=", "columnCount", "for", "col", "in", "list", "(", "np", ".", "random", ".", "choice", "(", "a", "=", "range", "(", "columnCount", ")", ",", "size", "=", "max_features", ",", "replace", "=", "False", ")", ")", ":", "columnValues", "=", "X", "[", ":", ",", "col", "]", "# unique values", "lsUnique", "=", "np", ".", "unique", "(", "columnValues", ")", "if", "(", "isinstance", "(", "lsUnique", "[", "0", "]", ",", "int", ")", "or", "isinstance", "(", "lsUnique", "[", "0", "]", ",", "float", ")", ")", ":", "if", "len", "(", "lsUnique", ")", ">", "10", ":", "lspercentile", "=", "np", ".", "percentile", "(", "columnValues", ",", "[", "3", ",", "5", ",", "10", ",", "20", ",", "30", ",", "50", ",", "70", ",", "80", ",", "90", ",", "95", ",", "97", "]", ")", "else", ":", "lspercentile", "=", "np", ".", "percentile", "(", "lsUnique", ",", "[", "10", ",", "50", ",", "90", "]", ")", "lsUnique", "=", "np", ".", "unique", "(", "lspercentile", ")", "for", "value", "in", "lsUnique", ":", "X_l", ",", "X_r", ",", "w_l", ",", "w_r", ",", "y_l", ",", "y_r", "=", "self", ".", "divideSet", "(", "X", ",", "treatment", ",", "y", ",", "col", ",", "value", ")", "# check the split validity on min_samples_leaf 372", "if", "(", "len", "(", "X_l", ")", "<", "min_samples_leaf", "or", "len", "(", "X_r", ")", "<", "min_samples_leaf", ")", ":", "continue", "# summarize notes", "# Gain -- Entropy or Gini", "p", "=", "float", "(", "len", "(", "X_l", ")", ")", "/", "len", "(", "X", ")", "leftNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_l", ",", "y_l", ",", "min_samples_treatment", "=", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "rightNodeSummary", "=", "self", ".", "tree_node_summary", "(", "w_r", ",", "y_r", ",", "min_samples_treatment", "=", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "# check the split validity on min_samples_treatment", "if", "set", "(", "leftNodeSummary", ".", "keys", "(", ")", ")", "!=", "set", "(", "rightNodeSummary", ".", "keys", "(", ")", ")", ":", "continue", "node_mst", "=", "10", "**", "8", "for", "ti", "in", "leftNodeSummary", ":", "node_mst", "=", "np", ".", "min", "(", "[", "node_mst", ",", "leftNodeSummary", "[", "ti", "]", "[", "1", "]", "]", ")", "node_mst", "=", "np", ".", "min", "(", "[", "node_mst", ",", "rightNodeSummary", "[", "ti", "]", "[", "1", "]", "]", ")", "if", "node_mst", "<", "min_samples_treatment", ":", "continue", "# evaluate the split", "if", "evaluationFunction", "==", "self", ".", "evaluate_CTS", ":", "leftScore1", "=", "evaluationFunction", "(", "leftNodeSummary", ")", "rightScore2", "=", "evaluationFunction", "(", "rightNodeSummary", ")", "gain", "=", "(", "currentScore", "-", "p", "*", "leftScore1", "-", "(", "1", "-", "p", ")", "*", "rightScore2", ")", "gain_for_imp", "=", "(", "len", "(", "X", ")", "*", "currentScore", "-", "len", "(", "X_l", ")", "*", "leftScore1", "-", "len", "(", "X_r", ")", "*", "rightScore2", ")", "elif", "evaluationFunction", "==", "self", ".", "evaluate_DDP", ":", "if", "self", ".", "control_name", "in", "leftNodeSummary", "and", "self", ".", "control_name", "in", "rightNodeSummary", ":", "leftScore1", "=", "evaluationFunction", "(", "leftNodeSummary", ",", "control_name", "=", "self", ".", "control_name", ")", "rightScore2", "=", "evaluationFunction", "(", "rightNodeSummary", ",", "control_name", "=", "self", ".", "control_name", ")", "gain", "=", "np", ".", "abs", "(", "leftScore1", "-", "rightScore2", ")", "gain_for_imp", "=", "np", ".", "abs", "(", "len", "(", "X_l", ")", "*", "leftScore1", "-", "len", "(", "X_r", ")", "*", "rightScore2", ")", "else", ":", "gain", "=", "0", "else", ":", "if", "(", "self", ".", "control_name", "in", "leftNodeSummary", "and", "self", ".", "control_name", "in", "rightNodeSummary", ")", ":", "leftScore1", "=", "evaluationFunction", "(", "leftNodeSummary", ",", "control_name", "=", "self", ".", "control_name", ")", "rightScore2", "=", "evaluationFunction", "(", "rightNodeSummary", ",", "control_name", "=", "self", ".", "control_name", ")", "gain", "=", "(", "p", "*", "leftScore1", "+", "(", "1", "-", "p", ")", "*", "rightScore2", "-", "currentScore", ")", "gain_for_imp", "=", "(", "len", "(", "X_l", ")", "*", "leftScore1", "+", "len", "(", "X_r", ")", "*", "rightScore2", "-", "len", "(", "X", ")", "*", "currentScore", ")", "if", "self", ".", "normalization", ":", "norm_factor", "=", "self", ".", "normI", "(", "currentNodeSummary", ",", "leftNodeSummary", ",", "rightNodeSummary", ",", "self", ".", "control_name", ",", "alpha", "=", "0.9", ")", "else", ":", "norm_factor", "=", "1", "gain", "=", "gain", "/", "norm_factor", "else", ":", "gain", "=", "0", "if", "(", "gain", ">", "bestGain", "and", "len", "(", "X_l", ")", ">", "min_samples_leaf", "and", "len", "(", "X_r", ")", ">", "min_samples_leaf", ")", ":", "bestGain", "=", "gain", "bestAttribute", "=", "(", "col", ",", "value", ")", "best_set_left", "=", "[", "X_l", ",", "w_l", ",", "y_l", "]", "best_set_right", "=", "[", "X_r", ",", "w_r", ",", "y_r", "]", "dcY", "=", "{", "'impurity'", ":", "'%.3f'", "%", "currentScore", ",", "'samples'", ":", "'%d'", "%", "len", "(", "X", ")", "}", "# Add treatment size", "dcY", "[", "'group_size'", "]", "=", "''", "for", "treatment_group", "in", "currentNodeSummary", ":", "dcY", "[", "'group_size'", "]", "+=", "' '", "+", "treatment_group", "+", "': '", "+", "str", "(", "currentNodeSummary", "[", "treatment_group", "]", "[", "1", "]", ")", "dcY", "[", "'upliftScore'", "]", "=", "[", "round", "(", "upliftScore", "[", "0", "]", ",", "4", ")", ",", "round", "(", "upliftScore", "[", "1", "]", ",", "4", ")", "]", "dcY", "[", "'matchScore'", "]", "=", "round", "(", "upliftScore", "[", "0", "]", ",", "4", ")", "if", "bestGain", ">", "0", "and", "depth", "<", "max_depth", ":", "self", ".", "feature_imp_dict", "[", "bestAttribute", "[", "0", "]", "]", "+=", "gain_for_imp", "trueBranch", "=", "self", ".", "growDecisionTreeFrom", "(", "*", "best_set_left", ",", "evaluationFunction", ",", "max_depth", ",", "min_samples_leaf", ",", "depth", "+", "1", ",", "min_samples_treatment", "=", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "falseBranch", "=", "self", ".", "growDecisionTreeFrom", "(", "*", "best_set_right", ",", "evaluationFunction", ",", "max_depth", ",", "min_samples_leaf", ",", "depth", "+", "1", ",", "min_samples_treatment", "=", "min_samples_treatment", ",", "n_reg", "=", "n_reg", ",", "parentNodeSummary", "=", "currentNodeSummary", ")", "return", "DecisionTree", "(", "col", "=", "bestAttribute", "[", "0", "]", ",", "value", "=", "bestAttribute", "[", "1", "]", ",", "trueBranch", "=", "trueBranch", ",", "falseBranch", "=", "falseBranch", ",", "summary", "=", "dcY", ",", "maxDiffTreatment", "=", "maxDiffTreatment", ",", "maxDiffSign", "=", "maxDiffSign", ",", "nodeSummary", "=", "currentNodeSummary", ",", "backupResults", "=", "self", ".", "uplift_classification_results", "(", "treatment", ",", "y", ")", ",", "bestTreatment", "=", "bestTreatment", ",", "upliftScore", "=", "upliftScore", ")", "else", ":", "if", "evaluationFunction", "==", "self", ".", "evaluate_CTS", ":", "return", "DecisionTree", "(", "results", "=", "self", ".", "uplift_classification_results", "(", "treatment", ",", "y", ")", ",", "summary", "=", "dcY", ",", "nodeSummary", "=", "currentNodeSummary", ",", "bestTreatment", "=", "bestTreatment", ",", "upliftScore", "=", "upliftScore", ")", "else", ":", "return", "DecisionTree", "(", "results", "=", "self", ".", "uplift_classification_results", "(", "treatment", ",", "y", ")", ",", "summary", "=", "dcY", ",", "maxDiffTreatment", "=", "maxDiffTreatment", ",", "maxDiffSign", "=", "maxDiffSign", ",", "nodeSummary", "=", "currentNodeSummary", ",", "bestTreatment", "=", "bestTreatment", ",", "upliftScore", "=", "upliftScore", ")" ]

[ 883, 4 ]

[ 1098, 17 ]

[ "def", "classify", "(", "observations", ",", "tree", ",", "dataMissing", "=", "False", ")", ":", "def", "classifyWithoutMissingData", "(", "observations", ",", "tree", ")", ":", "'''\n Classifies (prediction) the observations according to the tree, assuming without missing data.\n\n Args\n ----\n observations : list of list\n The internal data format for the training data (combining X, Y, treatment).\n\n Returns\n -------\n tree.results, tree.upliftScore :\n The results in the leaf node.\n '''", "if", "tree", ".", "results", "is", "not", "None", ":", "# leaf", "return", "tree", ".", "results", ",", "tree", ".", "upliftScore", "else", ":", "v", "=", "observations", "[", "tree", ".", "col", "]", "branch", "=", "None", "if", "isinstance", "(", "v", ",", "int", ")", "or", "isinstance", "(", "v", ",", "float", ")", ":", "if", "v", ">=", "tree", ".", "value", ":", "branch", "=", "tree", ".", "trueBranch", "else", ":", "branch", "=", "tree", ".", "falseBranch", "else", ":", "if", "v", "==", "tree", ".", "value", ":", "branch", "=", "tree", ".", "trueBranch", "else", ":", "branch", "=", "tree", ".", "falseBranch", "return", "classifyWithoutMissingData", "(", "observations", ",", "branch", ")", "def", "classifyWithMissingData", "(", "observations", ",", "tree", ")", ":", "'''\n Classifies (prediction) the observations according to the tree, assuming with missing data.\n\n Args\n ----\n observations : list of list\n The internal data format for the training data (combining X, Y, treatment).\n\n Returns\n -------\n tree.results, tree.upliftScore :\n The results in the leaf node.\n '''", "if", "tree", ".", "results", "is", "not", "None", ":", "# leaf", "return", "tree", ".", "results", "else", ":", "v", "=", "observations", "[", "tree", ".", "col", "]", "if", "v", "is", "None", ":", "tr", "=", "classifyWithMissingData", "(", "observations", ",", "tree", ".", "trueBranch", ")", "fr", "=", "classifyWithMissingData", "(", "observations", ",", "tree", ".", "falseBranch", ")", "tcount", "=", "sum", "(", "tr", ".", "values", "(", ")", ")", "fcount", "=", "sum", "(", "fr", ".", "values", "(", ")", ")", "tw", "=", "float", "(", "tcount", ")", "/", "(", "tcount", "+", "fcount", ")", "fw", "=", "float", "(", "fcount", ")", "/", "(", "tcount", "+", "fcount", ")", "# Problem description: http://blog.ludovf.net/python-collections-defaultdict/", "result", "=", "defaultdict", "(", "int", ")", "for", "k", ",", "v", "in", "tr", ".", "items", "(", ")", ":", "result", "[", "k", "]", "+=", "v", "*", "tw", "for", "k", ",", "v", "in", "fr", ".", "items", "(", ")", ":", "result", "[", "k", "]", "+=", "v", "*", "fw", "return", "dict", "(", "result", ")", "else", ":", "branch", "=", "None", "if", "isinstance", "(", "v", ",", "int", ")", "or", "isinstance", "(", "v", ",", "float", ")", ":", "if", "v", ">=", "tree", ".", "value", ":", "branch", "=", "tree", ".", "trueBranch", "else", ":", "branch", "=", "tree", ".", "falseBranch", "else", ":", "if", "v", "==", "tree", ".", "value", ":", "branch", "=", "tree", ".", "trueBranch", "else", ":", "branch", "=", "tree", ".", "falseBranch", "return", "classifyWithMissingData", "(", "observations", ",", "branch", ")", "# function body", "if", "dataMissing", ":", "return", "classifyWithMissingData", "(", "observations", ",", "tree", ")", "else", ":", "return", "classifyWithoutMissingData", "(", "observations", ",", "tree", ")" ]

[ 1101, 4 ]

[ 1201, 65 ]

[ "def", "__init__", "(", "self", ",", "n_estimators", "=", "10", ",", "max_features", "=", "10", ",", "random_state", "=", "2019", ",", "max_depth", "=", "5", ",", "min_samples_leaf", "=", "100", ",", "min_samples_treatment", "=", "10", ",", "n_reg", "=", "10", ",", "evaluationFunction", "=", "None", ",", "control_name", "=", "None", ",", "normalization", "=", "True", ",", "n_jobs", "=", "-", "1", ")", ":", "self", ".", "classes_", "=", "{", "}", "self", ".", "n_estimators", "=", "n_estimators", "self", ".", "max_features", "=", "max_features", "self", ".", "random_state", "=", "random_state", "self", ".", "max_depth", "=", "max_depth", "self", ".", "min_samples_leaf", "=", "min_samples_leaf", "self", ".", "min_samples_treatment", "=", "min_samples_treatment", "self", ".", "n_reg", "=", "n_reg", "self", ".", "evaluationFunction", "=", "evaluationFunction", "self", ".", "control_name", "=", "control_name", "self", ".", "n_jobs", "=", "n_jobs", "# Create forest", "self", ".", "uplift_forest", "=", "[", "]", "for", "_", "in", "range", "(", "n_estimators", ")", ":", "uplift_tree", "=", "UpliftTreeClassifier", "(", "max_features", "=", "self", ".", "max_features", ",", "max_depth", "=", "self", ".", "max_depth", ",", "min_samples_leaf", "=", "self", ".", "min_samples_leaf", ",", "min_samples_treatment", "=", "self", ".", "min_samples_treatment", ",", "n_reg", "=", "self", ".", "n_reg", ",", "evaluationFunction", "=", "self", ".", "evaluationFunction", ",", "control_name", "=", "self", ".", "control_name", ",", "normalization", "=", "normalization", ")", "self", ".", "uplift_forest", ".", "append", "(", "uplift_tree", ")", "if", "self", ".", "n_jobs", "==", "-", "1", ":", "self", ".", "n_jobs", "=", "mp", ".", "cpu_count", "(", ")" ]

[ 1253, 4 ]

[ 1295, 40 ]

[ "def", "fit", "(", "self", ",", "X", ",", "treatment", ",", "y", ")", ":", "np", ".", "random", ".", "seed", "(", "self", ".", "random_state", ")", "# Get treatment group keys", "treatment_group_keys", "=", "list", "(", "set", "(", "treatment", ")", ")", "treatment_group_keys", ".", "remove", "(", "self", ".", "control_name", ")", "treatment_group_keys", ".", "sort", "(", ")", "self", ".", "classes_", "=", "{", "}", "for", "i", ",", "treatment_group_key", "in", "enumerate", "(", "treatment_group_keys", ")", ":", "self", ".", "classes_", "[", "treatment_group_key", "]", "=", "i", "self", ".", "uplift_forest", "=", "(", "Parallel", "(", "n_jobs", "=", "self", ".", "n_jobs", ")", "(", "delayed", "(", "self", ".", "bootstrap", ")", "(", "X", ",", "treatment", ",", "y", ",", "tree", ")", "for", "tree", "in", "self", ".", "uplift_forest", ")", ")", "all_importances", "=", "[", "tree", ".", "feature_importances_", "for", "tree", "in", "self", ".", "uplift_forest", "]", "self", ".", "feature_importances_", "=", "np", ".", "mean", "(", "all_importances", ",", "axis", "=", "0", ")", "self", ".", "feature_importances_", "/=", "self", ".", "feature_importances_", ".", "sum", "(", ")" ]

[ 1297, 4 ]

[ 1329, 68 ]

[ "def", "predict", "(", "self", ",", "X", ",", "full_output", "=", "False", ")", ":", "df_res", "=", "pd", ".", "DataFrame", "(", ")", "y_pred_ensemble", "=", "dict", "(", ")", "y_pred_list", "=", "np", ".", "zeros", "(", "(", "X", ".", "shape", "[", "0", "]", ",", "len", "(", "self", ".", "classes_", ")", ")", ")", "# Make prediction by each tree", "for", "tree_i", "in", "range", "(", "len", "(", "self", ".", "uplift_forest", ")", ")", ":", "_", ",", "_", ",", "_", ",", "y_pred_full", "=", "self", ".", "uplift_forest", "[", "tree_i", "]", ".", "predict", "(", "X", "=", "X", ",", "full_output", "=", "True", ")", "if", "tree_i", "==", "0", ":", "for", "treatment_group", "in", "y_pred_full", ":", "y_pred_ensemble", "[", "treatment_group", "]", "=", "(", "np", ".", "array", "(", "y_pred_full", "[", "treatment_group", "]", ")", "/", "len", "(", "self", ".", "uplift_forest", ")", ")", "else", ":", "for", "treatment_group", "in", "y_pred_full", ":", "y_pred_ensemble", "[", "treatment_group", "]", "=", "(", "np", ".", "array", "(", "y_pred_ensemble", "[", "treatment_group", "]", ")", "+", "np", ".", "array", "(", "y_pred_full", "[", "treatment_group", "]", ")", "/", "len", "(", "self", ".", "uplift_forest", ")", ")", "# Summarize results into dataframe", "for", "treatment_group", "in", "y_pred_ensemble", ":", "df_res", "[", "treatment_group", "]", "=", "y_pred_ensemble", "[", "treatment_group", "]", "df_res", "[", "'recommended_treatment'", "]", "=", "df_res", ".", "apply", "(", "np", ".", "argmax", ",", "axis", "=", "1", ")", "# Calculate delta", "delta_cols", "=", "[", "]", "for", "treatment_group", "in", "y_pred_ensemble", ":", "if", "treatment_group", "!=", "self", ".", "control_name", ":", "delta_cols", ".", "append", "(", "'delta_%s'", "%", "(", "treatment_group", ")", ")", "df_res", "[", "'delta_%s'", "%", "(", "treatment_group", ")", "]", "=", "df_res", "[", "treatment_group", "]", "-", "df_res", "[", "self", ".", "control_name", "]", "# Add deltas to results list", "y_pred_list", "[", ":", ",", "self", ".", "classes_", "[", "treatment_group", "]", "]", "=", "df_res", "[", "'delta_%s'", "%", "(", "treatment_group", ")", "]", ".", "values", "df_res", "[", "'max_delta'", "]", "=", "df_res", "[", "delta_cols", "]", ".", "max", "(", "axis", "=", "1", ")", "if", "full_output", ":", "return", "df_res", "else", ":", "return", "y_pred_list" ]

[ 1341, 4 ]

[ 1406, 30 ]

[ "def", "num_to_str", "(", "f", ",", "precision", "=", "DEFAULT_PRECISION", ",", "use_locale", "=", "False", ",", "no_scientific", "=", "False", ")", ":", "assert", "not", "(", "use_locale", "and", "no_scientific", ")", "if", "precision", "!=", "DEFAULT_PRECISION", ":", "local_context", "=", "decimal", ".", "Context", "(", ")", "local_context", ".", "prec", "=", "precision", "else", ":", "local_context", "=", "ctx", "# We cast to string; we want to avoid precision issues, but format everything as though it were a float.", "# So, if it's not already a float, we will append a decimal point to the string representation", "s", "=", "repr", "(", "f", ")", "if", "not", "isinstance", "(", "f", ",", "float", ")", ":", "s", "+=", "locale", ".", "localeconv", "(", ")", ".", "get", "(", "\"decimal_point\"", ")", "+", "\"0\"", "d", "=", "local_context", ".", "create_decimal", "(", "s", ")", "if", "no_scientific", ":", "result", "=", "format", "(", "d", ",", "\"f\"", ")", "elif", "use_locale", ":", "result", "=", "format", "(", "d", ",", "\"n\"", ")", "else", ":", "result", "=", "format", "(", "d", ",", "\"g\"", ")", "if", "f", "!=", "locale", ".", "atof", "(", "result", ")", ":", "# result = '≈' + result", "# ≈ # \\u2248", "result", "=", "\"≈\" +", "r", "sult", "decimal_char", "=", "locale", ".", "localeconv", "(", ")", ".", "get", "(", "\"decimal_point\"", ")", "if", "\"e\"", "not", "in", "result", "and", "\"E\"", "not", "in", "result", "and", "decimal_char", "in", "result", ":", "result", "=", "result", ".", "rstrip", "(", "\"0\"", ")", ".", "rstrip", "(", "decimal_char", ")", "return", "result" ]

[ 18, 0 ]

[ 62, 17 ]

[ "def", "ordinal", "(", "num", ")", ":", "# Taken from https://codereview.stackexchange.com/questions/41298/producing-ordinal-numbers/41301", "# Consider a library like num2word when internationalization comes", "if", "10", "<=", "num", "%", "100", "<=", "20", ":", "suffix", "=", "\"th\"", "else", ":", "# the second parameter is a default.", "suffix", "=", "SUFFIXES", ".", "get", "(", "num", "%", "10", ",", "\"th\"", ")", "return", "str", "(", "num", ")", "+", "suffix" ]

[ 68, 0 ]

[ 77, 28 ]

[ "def", "substitute_none_for_missing", "(", "kwargs", ",", "kwarg_list", ")", ":", "new_kwargs", "=", "copy", ".", "deepcopy", "(", "kwargs", ")", "for", "kwarg", "in", "kwarg_list", ":", "if", "kwarg", "not", "in", "new_kwargs", ":", "new_kwargs", "[", "kwarg", "]", "=", "None", "return", "new_kwargs" ]

[ 114, 0 ]

[ 132, 21 ]

[ "def", "handle_strict_min_max", "(", "params", ":", "dict", ")", "->", "(", "str", ",", "str", ")", ":", "at_least_str", "=", "(", "\"greater than\"", "if", "params", ".", "get", "(", "\"strict_min\"", ")", "is", "True", "else", "\"greater than or equal to\"", ")", "at_most_str", "=", "(", "\"less than\"", "if", "params", ".", "get", "(", "\"strict_max\"", ")", "is", "True", "else", "\"less than or equal to\"", ")", "return", "at_least_str", ",", "at_most_str" ]

[ 178, 0 ]

[ 198, 36 ]

[ "def", "__init__", "(", "self", ",", "name", ":", "str", ",", "datasource_name", ":", "str", ",", "execution_engine", ":", "Optional", "[", "ExecutionEngine", "]", "=", "None", ",", "batch_spec_passthrough", ":", "Optional", "[", "dict", "]", "=", "None", ",", ")", ":", "self", ".", "_name", "=", "name", "self", ".", "_datasource_name", "=", "datasource_name", "self", ".", "_execution_engine", "=", "execution_engine", "# This is a dictionary which maps data_references onto batch_requests.", "self", ".", "_data_references_cache", "=", "{", "}", "self", ".", "_data_context_root_directory", "=", "None", "self", ".", "_batch_spec_passthrough", "=", "batch_spec_passthrough", "or", "{", "}" ]

[ 35, 4 ]

[ 59, 67 ]

[ "def", "get_batch_data_and_metadata", "(", "self", ",", "batch_definition", ":", "BatchDefinition", ",", ")", "->", "Tuple", "[", "Any", ",", "BatchSpec", ",", "BatchMarkers", ",", "]", ":", "# batch_data", "batch_spec", ":", "BatchSpec", "=", "self", ".", "build_batch_spec", "(", "batch_definition", "=", "batch_definition", ")", "batch_data", ",", "batch_markers", "=", "self", ".", "_execution_engine", ".", "get_batch_data_and_markers", "(", "batch_spec", "=", "batch_spec", ")", "self", ".", "_execution_engine", ".", "load_batch_data", "(", "batch_definition", ".", "id", ",", "batch_data", ")", "return", "(", "batch_data", ",", "batch_spec", ",", "batch_markers", ",", ")" ]

[ 81, 4 ]

[ 102, 9 ]

[ "def", "build_batch_spec", "(", "self", ",", "batch_definition", ":", "BatchDefinition", ")", "->", "BatchSpec", ":", "batch_spec_params", ":", "dict", "=", "(", "self", ".", "_generate_batch_spec_parameters_from_batch_definition", "(", "batch_definition", "=", "batch_definition", ")", ")", "# batch_spec_passthrough via Data Connector config", "batch_spec_passthrough", ":", "dict", "=", "deepcopy", "(", "self", ".", "batch_spec_passthrough", ")", "# batch_spec_passthrough from batch_definition supersedes batch_spec_passthrough from Data Connector config", "if", "isinstance", "(", "batch_definition", ".", "batch_spec_passthrough", ",", "dict", ")", ":", "batch_spec_passthrough", ".", "update", "(", "batch_definition", ".", "batch_spec_passthrough", ")", "batch_spec_params", ".", "update", "(", "batch_spec_passthrough", ")", "batch_spec", ":", "BatchSpec", "=", "BatchSpec", "(", "*", "*", "batch_spec_params", ")", "return", "batch_spec" ]

[ 104, 4 ]

[ 128, 25 ]

[ "def", "_get_data_reference_list", "(", "self", ",", "data_asset_name", ":", "Optional", "[", "str", "]", "=", "None", ")", "->", "List", "[", "str", "]", ":", "raise", "NotImplementedError" ]

[ 135, 4 ]

[ 146, 33 ]

[ "def", "_get_data_reference_list_from_cache_by_data_asset_name", "(", "self", ",", "data_asset_name", ":", "str", ")", "->", "List", "[", "Any", "]", ":", "raise", "NotImplementedError" ]

[ 148, 4 ]

[ 154, 33 ]

[ "def", "get_available_data_asset_names", "(", "self", ")", "->", "List", "[", "str", "]", ":", "raise", "NotImplementedError" ]

[ 162, 4 ]

[ 168, 33 ]

[ "def", "self_check", "(", "self", ",", "pretty_print", "=", "True", ",", "max_examples", "=", "3", ")", ":", "if", "len", "(", "self", ".", "_data_references_cache", ")", "==", "0", ":", "self", ".", "_refresh_data_references_cache", "(", ")", "if", "pretty_print", ":", "print", "(", "\"\\t\"", "+", "self", ".", "name", ",", "\":\"", ",", "self", ".", "__class__", ".", "__name__", ")", "print", "(", ")", "asset_names", "=", "self", ".", "get_available_data_asset_names", "(", ")", "asset_names", ".", "sort", "(", ")", "len_asset_names", "=", "len", "(", "asset_names", ")", "report_obj", "=", "{", "\"class_name\"", ":", "self", ".", "__class__", ".", "__name__", ",", "\"data_asset_count\"", ":", "len_asset_names", ",", "\"example_data_asset_names\"", ":", "asset_names", "[", ":", "max_examples", "]", ",", "\"data_assets\"", ":", "{", "}", "# \"data_reference_count\": self.", "}", "if", "pretty_print", ":", "print", "(", "f\"\\tAvailable data_asset_names ({min(len_asset_names, max_examples)} of {len_asset_names}):\"", ")", "for", "asset_name", "in", "asset_names", "[", ":", "max_examples", "]", ":", "data_reference_list", "=", "(", "self", ".", "_get_data_reference_list_from_cache_by_data_asset_name", "(", "data_asset_name", "=", "asset_name", ")", ")", "len_batch_definition_list", "=", "len", "(", "data_reference_list", ")", "example_data_references", "=", "data_reference_list", "[", ":", "max_examples", "]", "if", "pretty_print", ":", "print", "(", "f\"\\t\\t{asset_name} ({min(len_batch_definition_list, max_examples)} of {len_batch_definition_list}):\"", ",", "example_data_references", ",", ")", "report_obj", "[", "\"data_assets\"", "]", "[", "asset_name", "]", "=", "{", "\"batch_definition_count\"", ":", "len_batch_definition_list", ",", "\"example_data_references\"", ":", "example_data_references", ",", "}", "unmatched_data_references", "=", "self", ".", "get_unmatched_data_references", "(", ")", "len_unmatched_data_references", "=", "len", "(", "unmatched_data_references", ")", "if", "pretty_print", ":", "print", "(", "f\"\\n\\tUnmatched data_references ({min(len_unmatched_data_references, max_examples)} of {len_unmatched_data_references}):\"", ",", "unmatched_data_references", "[", ":", "max_examples", "]", ",", ")", "report_obj", "[", "\"unmatched_data_reference_count\"", "]", "=", "len_unmatched_data_references", "report_obj", "[", "\"example_unmatched_data_references\"", "]", "=", "unmatched_data_references", "[", ":", "max_examples", "]", "# FIXME: (Sam) Removing this temporarily since it's not supported by", "# some backends (e.g. BigQuery) and returns empty results for some", "# (e.g. MSSQL) - this needs some more work to be useful for all backends", "#", "# # Choose an example data_reference", "# if pretty_print:", "# print(\"\\n\\tChoosing an example data reference...\")", "#", "# example_data_reference = None", "#", "# available_references = report_obj[\"data_assets\"].items()", "# if len(available_references) == 0:", "# if pretty_print:", "# print(f\"\\t\\tNo references available.\")", "# return report_obj", "#", "# data_asset_name: Optional[str] = None", "# for tmp_data_asset_name, data_asset_return_obj in available_references:", "# if data_asset_return_obj[\"batch_definition_count\"] > 0:", "# example_data_reference = random.choice(", "# data_asset_return_obj[\"example_data_references\"]", "# )", "# data_asset_name = tmp_data_asset_name", "# break", "#", "# if example_data_reference is not None:", "# if pretty_print:", "# print(f\"\\t\\tReference chosen: {example_data_reference}\")", "#", "# # ...and fetch it.", "# if data_asset_name is None:", "# raise ValueError(", "# \"The data_asset_name for the chosen example data reference cannot be null.\"", "# )", "# report_obj[\"example_data_reference\"] = self._self_check_fetch_batch(", "# pretty_print=pretty_print,", "# example_data_reference=example_data_reference,", "# data_asset_name=data_asset_name,", "# )", "# else:", "# report_obj[\"example_data_reference\"] = {}", "return", "report_obj" ]

[ 191, 4 ]

[ 307, 25 ]

[ "def", "_self_check_fetch_batch", "(", "self", ",", "pretty_print", ":", "bool", ",", "example_data_reference", ":", "Any", ",", "data_asset_name", ":", "str", ",", ")", ":", "if", "pretty_print", ":", "print", "(", "f\"\\n\\t\\tFetching batch data...\"", ")", "batch_definition_list", ":", "List", "[", "BatchDefinition", "]", "=", "self", ".", "_map_data_reference_to_batch_definition_list", "(", "data_reference", "=", "example_data_reference", ",", "data_asset_name", "=", "data_asset_name", ",", ")", "assert", "len", "(", "batch_definition_list", ")", "==", "1", "batch_definition", ":", "BatchDefinition", "=", "batch_definition_list", "[", "0", "]", "# _execution_engine might be None for some tests", "if", "batch_definition", "is", "None", "or", "self", ".", "_execution_engine", "is", "None", ":", "return", "{", "}", "batch_data", ":", "Any", "batch_spec", ":", "BatchSpec", "batch_data", ",", "batch_spec", ",", "_", "=", "self", ".", "get_batch_data_and_metadata", "(", "batch_definition", "=", "batch_definition", ")", "# Note: get_batch_data_and_metadata will have loaded the data into the currently-defined execution engine.", "# Consequently, when we build a Validator, we do not need to specifically load the batch into it to", "# resolve metrics.", "validator", ":", "Validator", "=", "Validator", "(", "execution_engine", "=", "batch_data", ".", "execution_engine", ")", "data", ":", "Any", "=", "validator", ".", "get_metric", "(", "metric", "=", "MetricConfiguration", "(", "metric_name", "=", "\"table.head\"", ",", "metric_domain_kwargs", "=", "{", "\"batch_id\"", ":", "batch_definition", ".", "id", ",", "}", ",", "metric_value_kwargs", "=", "{", "\"n_rows\"", ":", "5", ",", "}", ",", ")", ")", "n_rows", ":", "int", "=", "validator", ".", "get_metric", "(", "metric", "=", "MetricConfiguration", "(", "metric_name", "=", "\"table.row_count\"", ",", "metric_domain_kwargs", "=", "{", "\"batch_id\"", ":", "batch_definition", ".", "id", ",", "}", ",", ")", ")", "if", "pretty_print", "and", "data", "is", "not", "None", ":", "print", "(", "f\"\\n\\t\\tShowing 5 rows\"", ")", "print", "(", "data", ")", "return", "{", "\"batch_spec\"", ":", "batch_spec", ",", "\"n_rows\"", ":", "n_rows", ",", "}" ]

[ 309, 4 ]

[ 378, 9 ]

[ "def", "_validate_batch_request", "(", "self", ",", "batch_request", ":", "BatchRequest", ")", ":", "if", "batch_request", ".", "datasource_name", "!=", "self", ".", "datasource_name", ":", "raise", "ValueError", "(", "f\"\"\"datasource_name in BatchRequest: \"{batch_request.datasource_name}\" does not match DataConnector datasource_name: \"{self.datasource_name}\".\"\"\"", ")", "if", "batch_request", ".", "data_connector_name", "!=", "self", ".", "name", ":", "raise", "ValueError", "(", "f\"\"\"data_connector_name in BatchRequest: \"{batch_request.data_connector_name}\" does not match DataConnector name: \"{self.name}\".\"\"\"", ")" ]

[ 380, 4 ]

[ 396, 13 ]

[ "def", "set_data_source", "(", "context", ",", "data_source_type", "=", "None", ")", ":", "data_source_name", "=", "None", "if", "not", "data_source_type", ":", "configured_datasources", "=", "[", "datasource", "for", "datasource", "in", "context", ".", "list_datasources", "(", ")", "]", "if", "len", "(", "configured_datasources", ")", "==", "0", ":", "display", "(", "HTML", "(", "\"\"\"\n<p>\nNo data sources found in the great_expectations.yml of your project.\n</p>\n\n<p>\nIf you did not create the data source during init, here is how to add it now: <a href=\"https://great-expectations.readthedocs.io/en/latest/how_to_add_data_source.html\">How To Add a Data Source</a>\n</p>\n\"\"\"", ")", ")", "elif", "len", "(", "configured_datasources", ")", ">", "1", ":", "display", "(", "HTML", "(", "\"\"\"\n<p>\nFound more than one data source in the great_expectations.yml of your project:\n<b>{1:s}</b>\n</p>\n<p>\nUncomment the next cell and set data_source_name to one of these names.\n</p>\n\"\"\"", ".", "format", "(", "data_source_type", ",", "\",\"", ".", "join", "(", "[", "datasource", "[", "\"name\"", "]", "for", "datasource", "in", "configured_datasources", "]", ")", ",", ")", ")", ")", "else", ":", "data_source_name", "=", "configured_datasources", "[", "0", "]", "[", "\"name\"", "]", "display", "(", "HTML", "(", "\"Will be using this data source from your project's great_expectations.yml: <b>{:s}</b>\"", ".", "format", "(", "data_source_name", ")", ")", ")", "else", ":", "configured_datasources", "=", "[", "datasource", "[", "\"name\"", "]", "for", "datasource", "in", "context", ".", "list_datasources", "(", ")", "if", "datasource", "[", "\"type\"", "]", "==", "data_source_type", "]", "if", "len", "(", "configured_datasources", ")", "==", "0", ":", "display", "(", "HTML", "(", "\"\"\"\n<p>\nNo {:s} data sources found in the great_expectations.yml of your project.\n</p>\n\n<p>\nIf you did not create the data source during init, here is how to add it now: <a href=\"https://great-expectations.readthedocs.io/en/latest/how_to_add_data_source.html\">How To Add a Data Source</a>\n</p>\n\"\"\"", ".", "format", "(", "data_source_type", ")", ")", ")", "elif", "len", "(", "configured_datasources", ")", ">", "1", ":", "display", "(", "HTML", "(", "\"\"\"\n<p>\nFound more than one {:s} data source in the great_expectations.yml of your project:\n<b>{:s}</b>\n</p>\n<p>\nUncomment the next cell and set data_source_name to one of these names.\n</p>\n\"\"\"", ".", "format", "(", "data_source_type", ",", "\",\"", ".", "join", "(", "configured_datasources", ")", ")", ")", ")", "else", ":", "data_source_name", "=", "configured_datasources", "[", "0", "]", "display", "(", "HTML", "(", "\"Will be using this {:s} data source from your project's great_expectations.yml: <b>{:s}</b>\"", ".", "format", "(", "data_source_type", ",", "data_source_name", ")", ")", ")", "return", "data_source_name" ]

[ 24, 0 ]

[ 130, 27 ]

[ "def", "setup_notebook_logging", "(", "logger", "=", "None", ",", "log_level", "=", "logging", ".", "INFO", ")", ":", "def", "posix2local", "(", "timestamp", ",", "tz", "=", "tzlocal", ".", "get_localzone", "(", ")", ")", ":", "\"\"\"Seconds since the epoch -> local time as an aware datetime object.\"\"\"", "return", "datetime", ".", "fromtimestamp", "(", "timestamp", ",", "tz", ")", "class", "Formatter", "(", "logging", ".", "Formatter", ")", ":", "def", "converter", "(", "self", ",", "timestamp", ")", ":", "return", "posix2local", "(", "timestamp", ")", "def", "formatTime", "(", "self", ",", "record", ",", "datefmt", "=", "None", ")", ":", "dt", "=", "self", ".", "converter", "(", "record", ".", "created", ")", "if", "datefmt", ":", "s", "=", "dt", ".", "strftime", "(", "datefmt", ")", "else", ":", "t", "=", "dt", ".", "strftime", "(", "self", ".", "default_time_format", ")", "s", "=", "self", ".", "default_msec_format", "%", "(", "t", ",", "record", ".", "msecs", ")", "return", "s", "if", "not", "logger", ":", "logger", "=", "logging", ".", "getLogger", "(", "\"great_expectations\"", ")", "chandler", "=", "logging", ".", "StreamHandler", "(", "stream", "=", "sys", ".", "stdout", ")", "chandler", ".", "setLevel", "(", "logging", ".", "DEBUG", ")", "# chandler.setFormatter(Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\", \"%Y-%m-%dT%H:%M:%S%z\"))", "chandler", ".", "setFormatter", "(", "Formatter", "(", "\"%(asctime)s - %(levelname)s - %(message)s\"", ",", "\"%Y-%m-%dT%H:%M:%S%z\"", ")", ")", "logger", ".", "addHandler", "(", "chandler", ")", "logger", ".", "setLevel", "(", "log_level", ")", "logger", ".", "info", "(", "\"Great Expectations logging enabled at %s level by JupyterUX module.\"", "%", "(", "log_level", ",", ")", ")" ]

[ 133, 0 ]

[ 171, 5 ]

[ "def", "show_available_data_asset_names", "(", "context", ",", "data_source_name", "=", "None", ")", ":", "# TODO: Needs tests.", "styles", "=", "\"\"\"\n <style type='text/css'>\n ul.data-assets {\n margin-top: 0px;\n }\n ul.data-assets li {\n line-height: 1.2em;\n list-style-type: circle;\n }\n ul.data-assets li span.expectation-suite {\n background: #ddd;\n }\n </style>\n \"\"\"", "print", "(", "\"Inspecting your data sources. This may take a moment...\"", ")", "expectation_suite_keys", "=", "context", ".", "list_expectation_suites", "(", ")", "datasources", "=", "context", ".", "list_datasources", "(", ")", "html", "=", "\"\"", "for", "datasource", "in", "datasources", ":", "if", "data_source_name", "and", "datasource", "[", "\"name\"", "]", "!=", "data_source_name", ":", "continue", "html", "+=", "\"<h2 style='margin: 0'>Datasource: {:s} ({:s})</h2>\"", ".", "format", "(", "datasource", "[", "\"name\"", "]", ",", "datasource", "[", "\"class_name\"", "]", ")", "ds", "=", "context", ".", "get_datasource", "(", "datasource", "[", "\"name\"", "]", ")", "generators", "=", "ds", ".", "list_batch_kwargs_generators", "(", ")", "for", "generator_info", "in", "generators", ":", "html", "+=", "\"batch_kwargs_generator: {:s} ({:s})\"", ".", "format", "(", "generator_info", "[", "\"name\"", "]", ",", "generator_info", "[", "\"class_name\"", "]", ")", "generator", "=", "ds", ".", "get_batch_kwargs_generator", "(", "generator_info", "[", "\"name\"", "]", ")", "# TODO hacks to deal w/ inconsistent return types. Remove urgently", "mystery_object", "=", "generator", ".", "get_available_data_asset_names", "(", ")", "if", "isinstance", "(", "mystery_object", ",", "dict", ")", "and", "\"names\"", "in", "mystery_object", ".", "keys", "(", ")", ":", "data_asset_names", "=", "sorted", "(", "[", "name", "[", "0", "]", "for", "name", "in", "mystery_object", "[", "\"names\"", "]", "]", ")", "elif", "isinstance", "(", "mystery_object", ",", "list", ")", ":", "data_asset_names", "=", "sorted", "(", "mystery_object", ")", "else", ":", "data_asset_names", "=", "[", "]", "if", "len", "(", "data_asset_names", ")", ">", "0", ":", "html", "+=", "\"<h3 style='margin: 0.2em 0'>Data Assets Found:</h3>\"", "html", "+=", "styles", "html", "+=", "\"<ul class='data-assets'>\"", "for", "data_asset_name", "in", "data_asset_names", ":", "html", "+=", "\"<li>{:s}</li>\"", ".", "format", "(", "data_asset_name", ")", "data_asset_expectation_suite_keys", "=", "[", "es_key", "for", "es_key", "in", "expectation_suite_keys", "if", "es_key", ".", "data_asset_name", ".", "datasource", "==", "datasource", "[", "\"name\"", "]", "and", "es_key", ".", "data_asset_name", ".", "generator", "==", "generator_info", "[", "\"name\"", "]", "and", "es_key", ".", "data_asset_name", ".", "generator_asset", "==", "data_asset_name", "]", "if", "len", "(", "data_asset_expectation_suite_keys", ")", ">", "0", ":", "html", "+=", "\"<ul>\"", "for", "es_key", "in", "data_asset_expectation_suite_keys", ":", "html", "+=", "\"<li><span class='expectation-suite'>Expectation Suite</span>: {:s}</li>\"", ".", "format", "(", "es_key", ".", "expectation_suite_name", ")", "html", "+=", "\"</ul>\"", "html", "+=", "\"</ul>\"", "else", ":", "display", "(", "HTML", "(", "\"\"\"<p>No data assets found in this data source.</p>\n<p>Read about how batch kwargs generators derive data assets from data sources:\n<a href=\"https://great-expectations.readthedocs.io/en/latest/how_to_add_data_source.html\">Data assets</a>\n</p>\"\"\"", ")", ")", "display", "(", "HTML", "(", "html", ")", ")" ]

[ 178, 0 ]

[ 253, 27 ]

[ "def", "display_column_expectations_as_section", "(", "expectation_suite", ",", "column", ",", "include_styling", "=", "True", ",", "return_without_displaying", "=", "False", ",", ")", ":", "# TODO: replace this with a generic utility function, preferably a method on an ExpectationSuite class", "column_expectation_list", "=", "[", "e", "for", "e", "in", "expectation_suite", ".", "expectations", "if", "\"column\"", "in", "e", ".", "kwargs", "and", "e", ".", "kwargs", "[", "\"column\"", "]", "==", "column", "]", "# TODO: Handle the case where zero evrs match the column name", "document", "=", "(", "ExpectationSuiteColumnSectionRenderer", "(", ")", ".", "render", "(", "column_expectation_list", ")", ".", "to_json_dict", "(", ")", ")", "view", "=", "DefaultJinjaSectionView", "(", ")", ".", "render", "(", "{", "\"section\"", ":", "document", ",", "\"section_loop\"", ":", "1", "}", ")", "return", "_render_for_jupyter", "(", "view", ",", "include_styling", ",", "return_without_displaying", ",", ")" ]

[ 328, 0 ]

[ 364, 5 ]

[ "def", "display_profiled_column_evrs_as_section", "(", "evrs", ",", "column", ",", "include_styling", "=", "True", ",", "return_without_displaying", "=", "False", ",", ")", ":", "# TODO: replace this with a generic utility function, preferably a method on an ExpectationSuite class", "column_evr_list", "=", "[", "e", "for", "e", "in", "evrs", ".", "results", "if", "\"column\"", "in", "e", ".", "expectation_config", ".", "kwargs", "and", "e", ".", "expectation_config", ".", "kwargs", "[", "\"column\"", "]", "==", "column", "]", "# TODO: Handle the case where zero evrs match the column name", "document", "=", "(", "ProfilingResultsColumnSectionRenderer", "(", ")", ".", "render", "(", "column_evr_list", ")", ".", "to_json_dict", "(", ")", ")", "view", "=", "DefaultJinjaSectionView", "(", ")", ".", "render", "(", "{", "\"section\"", ":", "document", ",", "\"section_loop\"", ":", "{", "\"index\"", ":", "1", "}", ",", "}", ")", "return", "_render_for_jupyter", "(", "view", ",", "include_styling", ",", "return_without_displaying", ",", ")" ]

[ 367, 0 ]

[ 408, 5 ]

[ "def", "display_column_evrs_as_section", "(", "evrs", ",", "column", ",", "include_styling", "=", "True", ",", "return_without_displaying", "=", "False", ",", ")", ":", "# TODO: replace this with a generic utility function, preferably a method on an ExpectationSuite class", "column_evr_list", "=", "[", "e", "for", "e", "in", "evrs", ".", "results", "if", "\"column\"", "in", "e", ".", "expectation_config", ".", "kwargs", "and", "e", ".", "expectation_config", ".", "kwargs", "[", "\"column\"", "]", "==", "column", "]", "# TODO: Handle the case where zero evrs match the column name", "document", "=", "(", "ValidationResultsColumnSectionRenderer", "(", ")", ".", "render", "(", "column_evr_list", ")", ".", "to_json_dict", "(", ")", ")", "view", "=", "DefaultJinjaSectionView", "(", ")", ".", "render", "(", "{", "\"section\"", ":", "document", ",", "\"section_loop\"", ":", "{", "\"index\"", ":", "1", "}", ",", "}", ")", "return", "_render_for_jupyter", "(", "view", ",", "include_styling", ",", "return_without_displaying", ",", ")" ]

[ 411, 0 ]

[ 447, 5 ]

[ "def", "__init__", "(", "self", ",", "rkey", ":", "str", ",", "location", ":", "str", "=", "\"-pragma-\"", ",", "*", ",", "name", ":", "str", "=", "\"-pragma-\"", ",", "kind", ":", "str", "=", "\"Pragma\"", ",", "apiVersion", ":", "Optional", "[", "str", "]", "=", "None", ",", "serialization", ":", "Optional", "[", "str", "]", "=", "None", ",", "*", "*", "kwargs", ")", "->", "None", ":", "# print(\"ACPragma __init__ (%s %s)\" % (kind, kwargs))", "# First init our superclass...", "super", "(", ")", ".", "__init__", "(", "rkey", ",", "location", ",", "kind", "=", "kind", ",", "name", "=", "name", ",", "apiVersion", "=", "apiVersion", ",", "serialization", "=", "serialization", ",", "*", "*", "kwargs", ")" ]

[ 29, 4 ]

[ 48, 34 ]

[ "def", "test_func", "(", ")", ":", "assert", "True" ]

[ 0, 0 ]

[ 2, 15 ]

[ "def", "__init__", "(", "self", ",", "name", "=", "None", ",", "decl_type", "=", "None", ",", "header_dir", "=", "None", ",", "header_file", "=", "None", ")", ":", "# An other option is that pygccxml will create absolute path using", "# os.path.abspath function. But I think this is just wrong, because", "# abspath builds path using current working directory. This behavior", "# is fragile and very difficult to find a bug.", "matcher_base_t", ".", "__init__", "(", "self", ")", "self", ".", "decl_type", "=", "decl_type", "self", ".", "__name", "=", "None", "self", ".", "__opt_is_tmpl_inst", "=", "None", "self", ".", "__opt_tmpl_name", "=", "None", "self", ".", "__opt_is_full_name", "=", "None", "self", ".", "__decl_name_only", "=", "None", "# Set the name through the setter.", "self", ".", "name", "=", "name", "self", ".", "header_dir", "=", "header_dir", "self", ".", "header_file", "=", "header_file", "if", "self", ".", "header_dir", ":", "self", ".", "header_dir", "=", "utils", ".", "normalize_path", "(", "self", ".", "header_dir", ")", "if", "not", "os", ".", "path", ".", "isabs", "(", "self", ".", "header_dir", ")", ":", "raise", "RuntimeError", "(", "\"Path to header directory should be absolute!\"", ")", "if", "self", ".", "header_file", ":", "self", ".", "header_file", "=", "utils", ".", "normalize_path", "(", "self", ".", "header_file", ")", "if", "not", "os", ".", "path", ".", "isabs", "(", "self", ".", "header_file", ")", ":", "raise", "RuntimeError", "(", "\"Path to header file should be absolute!\"", ")" ]

[ 29, 4 ]

[ 78, 77 ]

[ "def", "__init__", "(", "self", ",", "name", "=", "None", ",", "decl_type", "=", "None", ",", "header_dir", "=", "None", ",", "header_file", "=", "None", ")", ":", "declaration_matcher_t", ".", "__init__", "(", "self", ",", "name", "=", "name", ",", "decl_type", "=", "variable", ".", "variable_t", ",", "header_dir", "=", "header_dir", ",", "header_file", "=", "header_file", ")", "self", ".", "_decl_type", "=", "decl_type" ]

[ 189, 4 ]

[ 206, 35 ]

[ "def", "__init__", "(", "self", ",", "name", "=", "None", ",", "return_type", "=", "None", ",", "arg_types", "=", "None", ",", "decl_type", "=", "None", ",", "header_dir", "=", "None", ",", "header_file", "=", "None", ")", ":", "if", "None", "is", "decl_type", ":", "decl_type", "=", "calldef", ".", "calldef_t", "declaration_matcher_t", ".", "__init__", "(", "self", ",", "name", "=", "name", ",", "decl_type", "=", "decl_type", ",", "header_dir", "=", "header_dir", ",", "header_file", "=", "header_file", ")", "self", ".", "return_type", "=", "return_type", "self", ".", "arg_types", "=", "arg_types" ]

[ 260, 4 ]

[ 299, 34 ]

[ "def", "__init__", "(", "self", ",", "name", "=", "None", ",", "symbol", "=", "None", ",", "return_type", "=", "None", ",", "arg_types", "=", "None", ",", "decl_type", "=", "None", ",", "header_dir", "=", "None", ",", "header_file", "=", "None", ")", ":", "if", "None", "is", "decl_type", ":", "decl_type", "=", "calldef_members", ".", "operator_t", "calldef_matcher_t", ".", "__init__", "(", "self", ",", "name", "=", "name", ",", "return_type", "=", "return_type", ",", "arg_types", "=", "arg_types", ",", "decl_type", "=", "decl_type", ",", "header_dir", "=", "header_dir", ",", "header_file", "=", "header_file", ")", "self", ".", "symbol", "=", "symbol" ]

[ 358, 4 ]

[ 381, 28 ]

[ "def", "current_default_thread_limiter", "(", ")", ":", "try", ":", "limiter", "=", "_limiter_local", ".", "get", "(", ")", "except", "LookupError", ":", "limiter", "=", "CapacityLimiter", "(", "DEFAULT_LIMIT", ")", "_limiter_local", ".", "set", "(", "limiter", ")", "return", "limiter" ]

[ 32, 0 ]

[ 45, 18 ]

[ "async", "def", "to_thread_run_sync", "(", "sync_fn", ",", "*", "args", ",", "cancellable", "=", "False", ",", "limiter", "=", "None", ")", ":", "await", "trio", ".", "lowlevel", ".", "checkpoint_if_cancelled", "(", ")", "if", "limiter", "is", "None", ":", "limiter", "=", "current_default_thread_limiter", "(", ")", "# Holds a reference to the task that's blocked in this function waiting", "# for the result – or None if this function was cancelled and we should", "# discard the result.", "task_register", "=", "[", "trio", ".", "lowlevel", ".", "current_task", "(", ")", "]", "name", "=", "f\"trio.to_thread.run_sync-{next(_thread_counter)}\"", "placeholder", "=", "ThreadPlaceholder", "(", "name", ")", "# This function gets scheduled into the Trio run loop to deliver the", "# thread's result.", "def", "report_back_in_trio_thread_fn", "(", "result", ")", ":", "def", "do_release_then_return_result", "(", ")", ":", "# release_on_behalf_of is an arbitrary user-defined method, so it", "# might raise an error. If it does, we want that error to", "# replace the regular return value, and if the regular return was", "# already an exception then we want them to chain.", "try", ":", "return", "result", ".", "unwrap", "(", ")", "finally", ":", "limiter", ".", "release_on_behalf_of", "(", "placeholder", ")", "result", "=", "outcome", ".", "capture", "(", "do_release_then_return_result", ")", "if", "task_register", "[", "0", "]", "is", "not", "None", ":", "trio", ".", "lowlevel", ".", "reschedule", "(", "task_register", "[", "0", "]", ",", "result", ")", "current_trio_token", "=", "trio", ".", "lowlevel", ".", "current_trio_token", "(", ")", "def", "worker_fn", "(", ")", ":", "TOKEN_LOCAL", ".", "token", "=", "current_trio_token", "try", ":", "ret", "=", "sync_fn", "(", "*", "args", ")", "if", "inspect", ".", "iscoroutine", "(", "ret", ")", ":", "# Manually close coroutine to avoid RuntimeWarnings", "ret", ".", "close", "(", ")", "raise", "TypeError", "(", "\"Trio expected a sync function, but {!r} appears to be \"", "\"asynchronous\"", ".", "format", "(", "getattr", "(", "sync_fn", ",", "\"__qualname__\"", ",", "sync_fn", ")", ")", ")", "return", "ret", "finally", ":", "del", "TOKEN_LOCAL", ".", "token", "def", "deliver_worker_fn_result", "(", "result", ")", ":", "try", ":", "current_trio_token", ".", "run_sync_soon", "(", "report_back_in_trio_thread_fn", ",", "result", ")", "except", "trio", ".", "RunFinishedError", ":", "# The entire run finished, so the task we're trying to contact is", "# certainly long gone -- it must have been cancelled and abandoned", "# us.", "pass", "await", "limiter", ".", "acquire_on_behalf_of", "(", "placeholder", ")", "try", ":", "start_thread_soon", "(", "worker_fn", ",", "deliver_worker_fn_result", ")", "except", ":", "limiter", ".", "release_on_behalf_of", "(", "placeholder", ")", "raise", "def", "abort", "(", "_", ")", ":", "if", "cancellable", ":", "task_register", "[", "0", "]", "=", "None", "return", "trio", ".", "lowlevel", ".", "Abort", ".", "SUCCEEDED", "else", ":", "return", "trio", ".", "lowlevel", ".", "Abort", ".", "FAILED", "return", "await", "trio", ".", "lowlevel", ".", "wait_task_rescheduled", "(", "abort", ")" ]

[ 58, 0 ]

[ 206, 59 ]

[ "def", "_run_fn_as_system_task", "(", "cb", ",", "fn", ",", "*", "args", ",", "trio_token", "=", "None", ")", ":", "if", "trio_token", "and", "not", "isinstance", "(", "trio_token", ",", "TrioToken", ")", ":", "raise", "RuntimeError", "(", "\"Passed kwarg trio_token is not of type TrioToken\"", ")", "if", "not", "trio_token", ":", "try", ":", "trio_token", "=", "TOKEN_LOCAL", ".", "token", "except", "AttributeError", ":", "raise", "RuntimeError", "(", "\"this thread wasn't created by Trio, pass kwarg trio_token=...\"", ")", "# Avoid deadlock by making sure we're not called from Trio thread", "try", ":", "trio", ".", "lowlevel", ".", "current_task", "(", ")", "except", "RuntimeError", ":", "pass", "else", ":", "raise", "RuntimeError", "(", "\"this is a blocking function; call it from a thread\"", ")", "q", "=", "stdlib_queue", ".", "Queue", "(", ")", "trio_token", ".", "run_sync_soon", "(", "cb", ",", "q", ",", "fn", ",", "args", ")", "return", "q", ".", "get", "(", ")", ".", "unwrap", "(", ")" ]

[ 209, 0 ]

[ 237, 27 ]

[ "def", "from_thread_run", "(", "afn", ",", "*", "args", ",", "trio_token", "=", "None", ")", ":", "def", "callback", "(", "q", ",", "afn", ",", "args", ")", ":", "@", "disable_ki_protection", "async", "def", "unprotected_afn", "(", ")", ":", "coro", "=", "coroutine_or_error", "(", "afn", ",", "*", "args", ")", "return", "await", "coro", "async", "def", "await_in_trio_thread_task", "(", ")", ":", "q", ".", "put_nowait", "(", "await", "outcome", ".", "acapture", "(", "unprotected_afn", ")", ")", "try", ":", "trio", ".", "lowlevel", ".", "spawn_system_task", "(", "await_in_trio_thread_task", ",", "name", "=", "afn", ")", "except", "RuntimeError", ":", "# system nursery is closed", "q", ".", "put_nowait", "(", "outcome", ".", "Error", "(", "trio", ".", "RunFinishedError", "(", "\"system nursery is closed\"", ")", ")", ")", "return", "_run_fn_as_system_task", "(", "callback", ",", "afn", ",", "*", "args", ",", "trio_token", "=", "trio_token", ")" ]

[ 240, 0 ]

[ 291, 78 ]

[ "def", "from_thread_run_sync", "(", "fn", ",", "*", "args", ",", "trio_token", "=", "None", ")", ":", "def", "callback", "(", "q", ",", "fn", ",", "args", ")", ":", "@", "disable_ki_protection", "def", "unprotected_fn", "(", ")", ":", "ret", "=", "fn", "(", "*", "args", ")", "if", "inspect", ".", "iscoroutine", "(", "ret", ")", ":", "# Manually close coroutine to avoid RuntimeWarnings", "ret", ".", "close", "(", ")", "raise", "TypeError", "(", "\"Trio expected a sync function, but {!r} appears to be \"", "\"asynchronous\"", ".", "format", "(", "getattr", "(", "fn", ",", "\"__qualname__\"", ",", "fn", ")", ")", ")", "return", "ret", "res", "=", "outcome", ".", "capture", "(", "unprotected_fn", ")", "q", ".", "put_nowait", "(", "res", ")", "return", "_run_fn_as_system_task", "(", "callback", ",", "fn", ",", "*", "args", ",", "trio_token", "=", "trio_token", ")" ]

[ 294, 0 ]

[ 343, 77 ]

[ "def", "validate_configuration", "(", "self", ",", "configuration", ":", "Optional", "[", "ExpectationConfiguration", "]", ")", ":", "super", "(", ")", ".", "validate_configuration", "(", "configuration", ")", "try", ":", "assert", "\"value_set\"", "in", "configuration", ".", "kwargs", ",", "\"value_set is required\"", "assert", "(", "isinstance", "(", "configuration", ".", "kwargs", "[", "\"value_set\"", "]", ",", "(", "list", ",", "set", ",", "dict", ")", ")", "or", "configuration", ".", "kwargs", "[", "\"value_set\"", "]", "is", "None", ")", ",", "\"value_set must be a list, set, or None\"", "if", "isinstance", "(", "configuration", ".", "kwargs", "[", "\"value_set\"", "]", ",", "dict", ")", ":", "assert", "(", "\"$PARAMETER\"", "in", "configuration", ".", "kwargs", "[", "\"value_set\"", "]", ")", ",", "'Evaluation Parameter dict for value_set kwarg must have \"$PARAMETER\" key'", "except", "AssertionError", "as", "e", ":", "raise", "InvalidExpectationConfigurationError", "(", "str", "(", "e", ")", ")", "return", "True" ]

[ 271, 4 ]

[ 287, 19 ]

[ "def", "bind_aliases", "(", "decls", ")", ":", "warnings", ".", "warn", "(", "\"The bind_aliases function is deprecated\"", ",", "DeprecationWarning", ")", "declarations_joiner", ".", "bind_aliases", "(", "decls", ")" ]

[ 491, 0 ]

[ 505, 43 ]

[ "def", "__init__", "(", "self", ",", "configuration", ",", "cache", "=", "None", ",", "decl_factory", "=", "None", ")", ":", "self", ".", "logger", "=", "utils", ".", "loggers", ".", "cxx_parser", "self", ".", "__search_directories", "=", "[", "]", "self", ".", "__config", "=", "configuration", "self", ".", "__cxx_std", "=", "utils", ".", "cxx_standard", "(", "configuration", ".", "cflags", ")", "self", ".", "__search_directories", ".", "append", "(", "configuration", ".", "working_directory", ")", "self", ".", "__search_directories", ".", "extend", "(", "configuration", ".", "include_paths", ")", "if", "not", "cache", ":", "cache", "=", "declarations_cache", ".", "dummy_cache_t", "(", ")", "self", ".", "__dcache", "=", "cache", "self", ".", "__config", ".", "raise_on_wrong_settings", "(", ")", "self", ".", "__decl_factory", "=", "decl_factory", "if", "not", "decl_factory", ":", "self", ".", "__decl_factory", "=", "declarations", ".", "decl_factory_t", "(", ")", "self", ".", "__xml_generator_from_xml_file", "=", "None" ]

[ 42, 4 ]

[ 71, 49 ]

[ "def", "xml_generator_from_xml_file", "(", "self", ")", ":", "return", "self", ".", "__xml_generator_from_xml_file" ]

[ 74, 4 ]

[ 82, 49 ]

[ "def", "__create_command_line", "(", "self", ",", "source_file", ",", "xml_file", ")", ":", "if", "self", ".", "__config", ".", "xml_generator", "==", "\"gccxml\"", ":", "return", "self", ".", "__create_command_line_gccxml", "(", "source_file", ",", "xml_file", ")", "elif", "self", ".", "__config", ".", "xml_generator", "==", "\"castxml\"", ":", "return", "self", ".", "__create_command_line_castxml", "(", "source_file", ",", "xml_file", ")" ]

[ 84, 4 ]

[ 98, 76 ]

[ "def", "__add_symbols", "(", "self", ",", "cmd", ")", ":", "if", "self", ".", "__config", ".", "define_symbols", ":", "symbols", "=", "self", ".", "__config", ".", "define_symbols", "cmd", ".", "append", "(", "''", ".", "join", "(", "[", "' -D\"%s\"'", "%", "def_symbol", "for", "def_symbol", "in", "symbols", "]", ")", ")", "if", "self", ".", "__config", ".", "undefine_symbols", ":", "un_symbols", "=", "self", ".", "__config", ".", "undefine_symbols", "cmd", ".", "append", "(", "''", ".", "join", "(", "[", "' -U\"%s\"'", "%", "undef_symbol", "for", "undef_symbol", "in", "un_symbols", "]", ")", ")", "return", "cmd" ]

[ 239, 4 ]

[ 255, 18 ]

[ "def", "create_xml_file", "(", "self", ",", "source_file", ",", "destination", "=", "None", ")", ":", "xml_file", "=", "destination", "# If file specified, remove it to start else create new file name", "if", "xml_file", ":", "utils", ".", "remove_file_no_raise", "(", "xml_file", ",", "self", ".", "__config", ")", "else", ":", "xml_file", "=", "utils", ".", "create_temp_file_name", "(", "suffix", "=", "'.xml'", ")", "ffname", "=", "source_file", "if", "not", "os", ".", "path", ".", "isabs", "(", "ffname", ")", ":", "ffname", "=", "self", ".", "__file_full_name", "(", "source_file", ")", "command_line", "=", "self", ".", "__create_command_line", "(", "ffname", ",", "xml_file", ")", "process", "=", "subprocess", ".", "Popen", "(", "args", "=", "command_line", ",", "shell", "=", "True", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "try", ":", "gccxml_reports", "=", "[", "]", "while", "process", ".", "poll", "(", ")", "is", "None", ":", "line", "=", "process", ".", "stdout", ".", "readline", "(", ")", "if", "line", ".", "strip", "(", ")", ":", "gccxml_reports", ".", "append", "(", "line", ".", "rstrip", "(", ")", ")", "for", "line", "in", "process", ".", "stdout", ".", "readlines", "(", ")", ":", "if", "line", ".", "strip", "(", ")", ":", "gccxml_reports", ".", "append", "(", "line", ".", "rstrip", "(", ")", ")", "exit_status", "=", "process", ".", "returncode", "gccxml_msg", "=", "os", ".", "linesep", ".", "join", "(", "[", "str", "(", "s", ")", "for", "s", "in", "gccxml_reports", "]", ")", "if", "self", ".", "__config", ".", "ignore_gccxml_output", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "xml_file", ")", ":", "raise", "RuntimeError", "(", "\"Error occurred while running \"", "+", "self", ".", "__config", ".", "xml_generator", ".", "upper", "(", ")", "+", "\": %s status:%s\"", "%", "(", "gccxml_msg", ",", "exit_status", ")", ")", "else", ":", "if", "gccxml_msg", "or", "exit_status", "or", "not", "os", ".", "path", ".", "isfile", "(", "xml_file", ")", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "xml_file", ")", ":", "raise", "RuntimeError", "(", "\"Error occurred while running \"", "+", "self", ".", "__config", ".", "xml_generator", ".", "upper", "(", ")", "+", "\" xml file does not exist\"", ")", "else", ":", "raise", "RuntimeError", "(", "\"Error occurred while running \"", "+", "self", ".", "__config", ".", "xml_generator", ".", "upper", "(", ")", "+", "\": %s status:%s\"", "%", "(", "gccxml_msg", ",", "exit_status", ")", ")", "except", "Exception", ":", "utils", ".", "remove_file_no_raise", "(", "xml_file", ",", "self", ".", "__config", ")", "raise", "finally", ":", "process", ".", "wait", "(", ")", "process", ".", "stdout", ".", "close", "(", ")", "return", "xml_file" ]

[ 257, 4 ]

[ 330, 23 ]

[ "def", "create_xml_file_from_string", "(", "self", ",", "content", ",", "destination", "=", "None", ")", ":", "header_file", "=", "utils", ".", "create_temp_file_name", "(", "suffix", "=", "'.h'", ")", "try", ":", "with", "open", "(", "header_file", ",", "\"w+\"", ")", "as", "header", ":", "header", ".", "write", "(", "content", ")", "xml_file", "=", "self", ".", "create_xml_file", "(", "header_file", ",", "destination", ")", "finally", ":", "utils", ".", "remove_file_no_raise", "(", "header_file", ",", "self", ".", "__config", ")", "return", "xml_file" ]

[ 332, 4 ]

[ 352, 23 ]

[ "def", "read_cpp_source_file", "(", "self", ",", "source_file", ")", ":", "xml_file", "=", "''", "try", ":", "ffname", "=", "self", ".", "__file_full_name", "(", "source_file", ")", "self", ".", "logger", ".", "debug", "(", "\"Reading source file: [%s].\"", ",", "ffname", ")", "decls", "=", "self", ".", "__dcache", ".", "cached_value", "(", "ffname", ",", "self", ".", "__config", ")", "if", "not", "decls", ":", "self", ".", "logger", ".", "debug", "(", "\"File has not been found in cache, parsing...\"", ")", "xml_file", "=", "self", ".", "create_xml_file", "(", "ffname", ")", "decls", ",", "files", "=", "self", ".", "__parse_xml_file", "(", "xml_file", ")", "self", ".", "__dcache", ".", "update", "(", "ffname", ",", "self", ".", "__config", ",", "decls", ",", "files", ")", "else", ":", "self", ".", "logger", ".", "debug", "(", "(", "\"File has not been changed, reading declarations \"", "+", "\"from cache.\"", ")", ")", "except", "Exception", ":", "if", "xml_file", ":", "utils", ".", "remove_file_no_raise", "(", "xml_file", ",", "self", ".", "__config", ")", "raise", "if", "xml_file", ":", "utils", ".", "remove_file_no_raise", "(", "xml_file", ",", "self", ".", "__config", ")", "return", "decls" ]

[ 357, 4 ]

[ 389, 20 ]

[ "def", "read_xml_file", "(", "self", ",", "xml_file", ")", ":", "assert", "self", ".", "__config", "is", "not", "None", "ffname", "=", "self", ".", "__file_full_name", "(", "xml_file", ")", "self", ".", "logger", ".", "debug", "(", "\"Reading xml file: [%s]\"", ",", "xml_file", ")", "decls", "=", "self", ".", "__dcache", ".", "cached_value", "(", "ffname", ",", "self", ".", "__config", ")", "if", "not", "decls", ":", "self", ".", "logger", ".", "debug", "(", "\"File has not been found in cache, parsing...\"", ")", "decls", ",", "_", "=", "self", ".", "__parse_xml_file", "(", "ffname", ")", "self", ".", "__dcache", ".", "update", "(", "ffname", ",", "self", ".", "__config", ",", "decls", ",", "[", "]", ")", "else", ":", "self", ".", "logger", ".", "debug", "(", "\"File has not been changed, reading declarations from cache.\"", ")", "return", "decls" ]

[ 391, 4 ]

[ 415, 20 ]

[ "def", "read_string", "(", "self", ",", "content", ")", ":", "header_file", "=", "utils", ".", "create_temp_file_name", "(", "suffix", "=", "'.h'", ")", "with", "open", "(", "header_file", ",", "\"w+\"", ")", "as", "f", ":", "f", ".", "write", "(", "content", ")", "try", ":", "decls", "=", "self", ".", "read_file", "(", "header_file", ")", "except", "Exception", ":", "utils", ".", "remove_file_no_raise", "(", "header_file", ",", "self", ".", "__config", ")", "raise", "utils", ".", "remove_file_no_raise", "(", "header_file", ",", "self", ".", "__config", ")", "return", "decls" ]

[ 417, 4 ]

[ 435, 20 ]

[ "def", "Load", "(", "build_files", ",", "format", ",", "default_variables", "=", "{", "}", ",", "includes", "=", "[", "]", ",", "depth", "=", "'.'", ",", "params", "=", "None", ",", "check", "=", "False", ",", "circular_check", "=", "True", ",", "duplicate_basename_check", "=", "True", ")", ":", "if", "params", "is", "None", ":", "params", "=", "{", "}", "if", "'-'", "in", "format", ":", "format", ",", "params", "[", "'flavor'", "]", "=", "format", ".", "split", "(", "'-'", ",", "1", ")", "default_variables", "=", "copy", ".", "copy", "(", "default_variables", ")", "# Default variables provided by this program and its modules should be", "# named WITH_CAPITAL_LETTERS to provide a distinct \"best practice\" namespace,", "# avoiding collisions with user and automatic variables.", "default_variables", "[", "'GENERATOR'", "]", "=", "format", "default_variables", "[", "'GENERATOR_FLAVOR'", "]", "=", "params", ".", "get", "(", "'flavor'", ",", "''", ")", "# Format can be a custom python file, or by default the name of a module", "# within gyp.generator.", "if", "format", ".", "endswith", "(", "'.py'", ")", ":", "generator_name", "=", "os", ".", "path", ".", "splitext", "(", "format", ")", "[", "0", "]", "path", ",", "generator_name", "=", "os", ".", "path", ".", "split", "(", "generator_name", ")", "# Make sure the path to the custom generator is in sys.path", "# Don't worry about removing it once we are done. Keeping the path", "# to each generator that is used in sys.path is likely harmless and", "# arguably a good idea.", "path", "=", "os", ".", "path", ".", "abspath", "(", "path", ")", "if", "path", "not", "in", "sys", ".", "path", ":", "sys", ".", "path", ".", "insert", "(", "0", ",", "path", ")", "else", ":", "generator_name", "=", "'gyp.generator.'", "+", "format", "# These parameters are passed in order (as opposed to by key)", "# because ActivePython cannot handle key parameters to __import__.", "generator", "=", "__import__", "(", "generator_name", ",", "globals", "(", ")", ",", "locals", "(", ")", ",", "generator_name", ")", "for", "(", "key", ",", "val", ")", "in", "generator", ".", "generator_default_variables", ".", "items", "(", ")", ":", "default_variables", ".", "setdefault", "(", "key", ",", "val", ")", "# Give the generator the opportunity to set additional variables based on", "# the params it will receive in the output phase.", "if", "getattr", "(", "generator", ",", "'CalculateVariables'", ",", "None", ")", ":", "generator", ".", "CalculateVariables", "(", "default_variables", ",", "params", ")", "# Give the generator the opportunity to set generator_input_info based on", "# the params it will receive in the output phase.", "if", "getattr", "(", "generator", ",", "'CalculateGeneratorInputInfo'", ",", "None", ")", ":", "generator", ".", "CalculateGeneratorInputInfo", "(", "params", ")", "# Fetch the generator specific info that gets fed to input, we use getattr", "# so we can default things and the generators only have to provide what", "# they need.", "generator_input_info", "=", "{", "'non_configuration_keys'", ":", "getattr", "(", "generator", ",", "'generator_additional_non_configuration_keys'", ",", "[", "]", ")", ",", "'path_sections'", ":", "getattr", "(", "generator", ",", "'generator_additional_path_sections'", ",", "[", "]", ")", ",", "'extra_sources_for_rules'", ":", "getattr", "(", "generator", ",", "'generator_extra_sources_for_rules'", ",", "[", "]", ")", ",", "'generator_supports_multiple_toolsets'", ":", "getattr", "(", "generator", ",", "'generator_supports_multiple_toolsets'", ",", "False", ")", ",", "'generator_wants_static_library_dependencies_adjusted'", ":", "getattr", "(", "generator", ",", "'generator_wants_static_library_dependencies_adjusted'", ",", "True", ")", ",", "'generator_wants_sorted_dependencies'", ":", "getattr", "(", "generator", ",", "'generator_wants_sorted_dependencies'", ",", "False", ")", ",", "'generator_filelist_paths'", ":", "getattr", "(", "generator", ",", "'generator_filelist_paths'", ",", "None", ")", ",", "}", "# Process the input specific to this generator.", "result", "=", "gyp", ".", "input", ".", "Load", "(", "build_files", ",", "default_variables", ",", "includes", "[", ":", "]", ",", "depth", ",", "generator_input_info", ",", "check", ",", "circular_check", ",", "duplicate_basename_check", ",", "params", "[", "'parallel'", "]", ",", "params", "[", "'root_targets'", "]", ")", "return", "[", "generator", "]", "+", "result" ]

[ 49, 0 ]

[ 130, 29 ]

[ "def", "NameValueListToDict", "(", "name_value_list", ")", ":", "result", "=", "{", "}", "for", "item", "in", "name_value_list", ":", "tokens", "=", "item", ".", "split", "(", "'='", ",", "1", ")", "if", "len", "(", "tokens", ")", "==", "2", ":", "# If we can make it an int, use that, otherwise, use the string.", "try", ":", "token_value", "=", "int", "(", "tokens", "[", "1", "]", ")", "except", "ValueError", ":", "token_value", "=", "tokens", "[", "1", "]", "# Set the variable to the supplied value.", "result", "[", "tokens", "[", "0", "]", "]", "=", "token_value", "else", ":", "# No value supplied, treat it as a boolean and set it.", "result", "[", "tokens", "[", "0", "]", "]", "=", "True", "return", "result" ]

[ 132, 0 ]

[ 152, 15 ]

[ "def", "RegenerateAppendFlag", "(", "flag", ",", "values", ",", "predicate", ",", "env_name", ",", "options", ")", ":", "flags", "=", "[", "]", "if", "options", ".", "use_environment", "and", "env_name", ":", "for", "flag_value", "in", "ShlexEnv", "(", "env_name", ")", ":", "value", "=", "FormatOpt", "(", "flag", ",", "predicate", "(", "flag_value", ")", ")", "if", "value", "in", "flags", ":", "flags", ".", "remove", "(", "value", ")", "flags", ".", "append", "(", "value", ")", "if", "values", ":", "for", "flag_value", "in", "values", ":", "flags", ".", "append", "(", "FormatOpt", "(", "flag", ",", "predicate", "(", "flag_value", ")", ")", ")", "return", "flags" ]

[ 165, 0 ]

[ 185, 14 ]

[ "def", "RegenerateFlags", "(", "options", ")", ":", "def", "FixPath", "(", "path", ")", ":", "path", "=", "gyp", ".", "common", ".", "FixIfRelativePath", "(", "path", ",", "options", ".", "depth", ")", "if", "not", "path", ":", "return", "os", ".", "path", ".", "curdir", "return", "path", "def", "Noop", "(", "value", ")", ":", "return", "value", "# We always want to ignore the environment when regenerating, to avoid", "# duplicate or changed flags in the environment at the time of regeneration.", "flags", "=", "[", "'--ignore-environment'", "]", "for", "name", ",", "metadata", "in", "options", ".", "_regeneration_metadata", ".", "iteritems", "(", ")", ":", "opt", "=", "metadata", "[", "'opt'", "]", "value", "=", "getattr", "(", "options", ",", "name", ")", "value_predicate", "=", "metadata", "[", "'type'", "]", "==", "'path'", "and", "FixPath", "or", "Noop", "action", "=", "metadata", "[", "'action'", "]", "env_name", "=", "metadata", "[", "'env_name'", "]", "if", "action", "==", "'append'", ":", "flags", ".", "extend", "(", "RegenerateAppendFlag", "(", "opt", ",", "value", ",", "value_predicate", ",", "env_name", ",", "options", ")", ")", "elif", "action", "in", "(", "'store'", ",", "None", ")", ":", "# None is a synonym for 'store'.", "if", "value", ":", "flags", ".", "append", "(", "FormatOpt", "(", "opt", ",", "value_predicate", "(", "value", ")", ")", ")", "elif", "options", ".", "use_environment", "and", "env_name", "and", "os", ".", "environ", ".", "get", "(", "env_name", ")", ":", "flags", ".", "append", "(", "FormatOpt", "(", "opt", ",", "value_predicate", "(", "os", ".", "environ", ".", "get", "(", "env_name", ")", ")", ")", ")", "elif", "action", "in", "(", "'store_true'", ",", "'store_false'", ")", ":", "if", "(", "(", "action", "==", "'store_true'", "and", "value", ")", "or", "(", "action", "==", "'store_false'", "and", "not", "value", ")", ")", ":", "flags", ".", "append", "(", "opt", ")", "elif", "options", ".", "use_environment", "and", "env_name", ":", "print", ">>", "sys", ".", "stderr", ",", "(", "'Warning: environment regeneration unimplemented '", "'for %s flag %r env_name %r'", "%", "(", "action", ",", "opt", ",", "env_name", ")", ")", "else", ":", "print", ">>", "sys", ".", "stderr", ",", "(", "'Warning: regeneration unimplemented for action %r '", "'flag %r'", "%", "(", "action", ",", "opt", ")", ")", "return", "flags" ]

[ 187, 0 ]

[ 235, 14 ]

[ "def", "add_option", "(", "self", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "env_name", "=", "kw", ".", "pop", "(", "'env_name'", ",", "None", ")", "if", "'dest'", "in", "kw", "and", "kw", ".", "pop", "(", "'regenerate'", ",", "True", ")", ":", "dest", "=", "kw", "[", "'dest'", "]", "# The path type is needed for regenerating, for optparse we can just treat", "# it as a string.", "type", "=", "kw", ".", "get", "(", "'type'", ")", "if", "type", "==", "'path'", ":", "kw", "[", "'type'", "]", "=", "'string'", "self", ".", "__regeneratable_options", "[", "dest", "]", "=", "{", "'action'", ":", "kw", ".", "get", "(", "'action'", ")", ",", "'type'", ":", "type", ",", "'env_name'", ":", "env_name", ",", "'opt'", ":", "args", "[", "0", "]", ",", "}", "optparse", ".", "OptionParser", ".", "add_option", "(", "self", ",", "*", "args", ",", "*", "*", "kw", ")" ]

[ 242, 2 ]

[ 271, 55 ]

[ "def", "aws_credentials", "(", ")", ":", "os", ".", "environ", "[", "\"AWS_ACCESS_KEY_ID\"", "]", "=", "\"testing\"", "os", ".", "environ", "[", "\"AWS_SECRET_ACCESS_KEY\"", "]", "=", "\"testing\"", "os", ".", "environ", "[", "\"AWS_SECURITY_TOKEN\"", "]", "=", "\"testing\"", "os", ".", "environ", "[", "\"AWS_SESSION_TOKEN\"", "]", "=", "\"testing\"" ]

[ 335, 0 ]

[ 340, 47 ]

[ "def", "get_style_defs", "(", "self", ",", "arg", "=", "''", ")", ":", "cp", "=", "self", ".", "commandprefix", "styles", "=", "[", "]", "for", "name", ",", "definition", "in", "iteritems", "(", "self", ".", "cmd2def", ")", ":", "styles", ".", "append", "(", "r'\\expandafter\\def\\csname %s@tok@%s\\endcsname{%s}'", "%", "(", "cp", ",", "name", ",", "definition", ")", ")", "return", "STYLE_TEMPLATE", "%", "{", "'cp'", ":", "self", ".", "commandprefix", ",", "'styles'", ":", "'\\n'", ".", "join", "(", "styles", ")", "}" ]

[ 317, 4 ]

[ 328, 61 ]

[ "def", "lone_object_filter", "(", "image", ",", "min_size", "=", "2", ",", "connectivity", "=", "1", ",", "kernel_size", "=", "3", ")", ":", "assert", "kernel_size", "%", "2", "==", "1", ",", "\"The parameter `kernel_size` must be an odd number.\"", "image_min", ",", "image_max", "=", "image", ".", "min", "(", ")", ",", "image", ".", "max", "(", ")", "image_dtype", "=", "image", ".", "dtype", "image", "=", "np", ".", "interp", "(", "image", ",", "[", "image_min", ",", "image_max", "]", ",", "[", "0", ",", "255", "]", ")", ".", "astype", "(", "np", ".", "uint8", ")", "modal_filtered", "=", "modal", "(", "image", ",", "create_circular_mask", "(", "kernel_size", ",", "kernel_size", ")", ")", "da", "=", "xr", ".", "DataArray", "(", "image", ")", "for", "i", ",", "val", "in", "enumerate", "(", "np", ".", "unique", "(", "image", ")", ")", ":", "# Determine the pixels with this value that will be not be filtered (True to keep).", "layer", "=", "remove_small_objects", "(", "image", "==", "val", ",", "min_size", "=", "min_size", ",", "connectivity", "=", "connectivity", ")", "# Select the values from the image that will remain (filter it).", "filtered", "=", "da", ".", "where", "(", "layer", ")", "if", "i", "==", "0", "else", "filtered", ".", "combine_first", "(", "da", ".", "where", "(", "layer", ")", ")", "# Fill in the removed values with their local modes.", "filtered_nan_mask", "=", "np", ".", "isnan", "(", "filtered", ".", "values", ")", "filtered", ".", "values", "[", "filtered_nan_mask", "]", "=", "modal_filtered", "[", "filtered_nan_mask", "]", "filtered", ".", "values", "=", "np", ".", "interp", "(", "filtered", ".", "values", ",", "[", "0", ",", "255", "]", ",", "[", "image_min", ",", "image_max", "]", ")", ".", "astype", "(", "image_dtype", ")", "return", "filtered", ".", "values" ]

[ 9, 0 ]

[ 66, 26 ]

[ "def", "apply_filter", "(", "statistic", ",", "filter_output", ",", "padded_arr", ",", "filter_shape", ")", ":", "# For each point in the first two dimensions of `dataarray`...", "for", "i", "in", "range", "(", "filter_output", ".", "shape", "[", "0", "]", ")", ":", "for", "j", "in", "range", "(", "filter_output", ".", "shape", "[", "1", "]", ")", ":", "padded_arr_segment", "=", "padded_arr", "[", "i", ":", "i", "+", "filter_shape", "[", "0", "]", ",", "j", ":", "j", "+", "filter_shape", "[", "1", "]", "]", "if", "statistic", "==", "'mean'", ":", "filter_output", ".", "values", "[", "i", ",", "j", "]", "=", "np", ".", "nanmean", "(", "padded_arr_segment", ")", "elif", "statistic", "==", "'median'", ":", "filter_output", ".", "values", "[", "i", ",", "j", "]", "=", "np", ".", "nanmedian", "(", "padded_arr_segment", ")", "elif", "statistic", "==", "'std'", ":", "filter_output", ".", "values", "[", "i", ",", "j", "]", "=", "np", ".", "nanstd", "(", "padded_arr_segment", ")", "return", "filter_output" ]

[ 72, 0 ]

[ 102, 24 ]

[ "def", "stats_filter_3d_composite_2d", "(", "dataarray", ",", "statistic", ",", "filter_size", "=", "1", ",", "time_dim", "=", "'time'", ")", ":", "time_ax_num", "=", "dataarray", ".", "get_axis_num", "(", "time_dim", ")", "dataarray_non_time_dims", "=", "np", ".", "concatenate", "(", "(", "np", ".", "arange", "(", "time_ax_num", ")", ",", "np", ".", "arange", "(", "time_ax_num", "+", "1", ",", "len", "(", "dataarray", ".", "dims", ")", ")", ")", ")", "filter_dims", "=", "np", ".", "array", "(", "dataarray", ".", "dims", ")", "[", "dataarray_non_time_dims", "]", "filter_coords", "=", "{", "dim", ":", "dataarray", ".", "coords", "[", "dim", "]", "for", "dim", "in", "filter_dims", "}", "filter_output", "=", "xr", ".", "DataArray", "(", "np", ".", "full", "(", "np", ".", "array", "(", "dataarray", ".", "shape", ")", "[", "dataarray_non_time_dims", "]", ",", "np", ".", "nan", ")", ",", "coords", "=", "filter_coords", ",", "dims", "=", "filter_dims", ")", "if", "filter_size", "==", "1", ":", "agg_func_kwargs", "=", "dict", "(", "a", "=", "dataarray", ".", "values", ",", "axis", "=", "time_ax_num", ")", "if", "statistic", "==", "'mean'", ":", "filter_output", ".", "values", "[", ":", "]", "=", "np", ".", "nanmean", "(", "*", "*", "agg_func_kwargs", ")", "elif", "statistic", "==", "'median'", ":", "filter_output", ".", "values", "[", ":", "]", "=", "np", ".", "nanmedian", "(", "*", "*", "agg_func_kwargs", ")", "elif", "statistic", "==", "'std'", ":", "filter_output", ".", "values", "[", ":", "]", "=", "np", ".", "nanstd", "(", "*", "*", "agg_func_kwargs", ")", "else", ":", "# Allocate a Numpy array containing the content of `dataarray`, but padded", "# with NaNs to ensure the statistics are correct at the x and y extremities of the data.", "flt_shp", "=", "np", ".", "array", "(", "(", "filter_size", ",", "filter_size", ")", ")", "shp", "=", "np", ".", "array", "(", "dataarray", ".", "shape", ")", "[", "dataarray_non_time_dims", "]", "pad_shp", "=", "(", "*", "(", "shp", "+", "flt_shp", "-", "1", ")", ",", "dataarray", ".", "shape", "[", "time_ax_num", "]", ")", "padding", "=", "(", "flt_shp", "-", "1", ")", "//", "2", "# The number of NaNs from an edge of the padding to the data.", "padded_arr", "=", "np", ".", "full", "(", "pad_shp", ",", "np", ".", "nan", ")", "padded_arr", "[", "padding", "[", "0", "]", ":", "pad_shp", "[", "0", "]", "-", "padding", "[", "0", "]", ",", "padding", "[", "1", "]", ":", "pad_shp", "[", "1", "]", "-", "padding", "[", "1", "]", "]", "=", "dataarray", ".", "values", "filter_output", "=", "apply_filter", "(", "statistic", ",", "filter_output", ",", "padded_arr", ",", "flt_shp", ")", "return", "filter_output" ]

[ 105, 0 ]

[ 158, 24 ]

[ "def", "stats_filter_2d", "(", "dataarray", ",", "statistic", ",", "filter_size", "=", "3", ")", ":", "if", "filter_size", "==", "1", ":", "return", "dataarray", "filter_output", "=", "dataarray", ".", "copy", "(", ")", "kernel", "=", "np", ".", "ones", "(", "(", "filter_size", ",", "filter_size", ")", ")", "if", "statistic", "==", "'mean'", ":", "filter_output", ".", "values", "[", ":", "]", "=", "scipy", ".", "signal", ".", "convolve2d", "(", "filter_output", ".", "values", ",", "kernel", ",", "mode", "=", "\"same\"", ")", "/", "kernel", ".", "size", "elif", "statistic", "==", "'median'", ":", "filter_output", ".", "values", "[", ":", "]", "=", "scipy", ".", "ndimage", ".", "median_filter", "(", "filter_output", ".", "values", ",", "footprint", "=", "kernel", ")", "elif", "statistic", "==", "'std'", ":", "# Calculate standard deviation as stddev(X) = sqrt(E(X^2) - E(X)^2).", "im", "=", "dataarray", ".", "values", "im2", "=", "im", "**", "2", "ones", "=", "np", ".", "ones", "(", "im", ".", "shape", ")", "s", "=", "scipy", ".", "signal", ".", "convolve2d", "(", "im", ",", "kernel", ",", "mode", "=", "\"same\"", ")", "s2", "=", "scipy", ".", "signal", ".", "convolve2d", "(", "im2", ",", "kernel", ",", "mode", "=", "\"same\"", ")", "ns", "=", "scipy", ".", "signal", ".", "convolve2d", "(", "ones", ",", "kernel", ",", "mode", "=", "\"same\"", ")", "filter_output", ".", "values", "[", ":", "]", "=", "np", ".", "sqrt", "(", "(", "s2", "-", "s", "**", "2", "/", "ns", ")", "/", "ns", ")", "return", "filter_output" ]

[ 161, 0 ]

[ 201, 24 ]

[ "def", "test_users_listed", "(", "self", ")", ":", "url", "=", "reverse", "(", "'admin:core_user_changelist'", ")", "res", "=", "self", ".", "client", ".", "get", "(", "url", ")", "self", ".", "assertContains", "(", "res", ",", "self", ".", "user", ".", "name", ")", "self", ".", "assertContains", "(", "res", ",", "self", ".", "user", ".", "email", ")" ]

[ 20, 4 ]

[ 26, 49 ]

[ "def", "test_user_change_page", "(", "self", ")", ":", "url", "=", "reverse", "(", "'admin:core_user_change'", ",", "args", "=", "[", "self", ".", "user", ".", "id", "]", ")", "res", "=", "self", ".", "client", ".", "get", "(", "url", ")", "self", ".", "assertEqual", "(", "res", ".", "status_code", ",", "200", ")" ]

[ 28, 4 ]

[ 33, 46 ]

[ "def", "test_create_user_page", "(", "self", ")", ":", "url", "=", "reverse", "(", "'admin:core_user_add'", ")", "res", "=", "self", ".", "client", ".", "get", "(", "url", ")", "self", ".", "assertEqual", "(", "res", ".", "status_code", ",", "200", ")" ]

[ 35, 4 ]

[ 40, 46 ]

[ "def", "testStarted", "(", "self", ",", "testName", ",", "captureStandardOutput", "=", "None", ",", "flowId", "=", "None", ",", "metainfo", "=", "None", ")", ":", "self", ".", "message", "(", "'testStarted'", ",", "name", "=", "testName", ",", "captureStandardOutput", "=", "captureStandardOutput", ",", "flowId", "=", "flowId", ",", "metainfo", "=", "metainfo", ")" ]

[ 144, 4 ]

[ 149, 129 ]

[ "def", "_library_not_loaded_test", "(", "tmp_path_factory", ",", "cli_input", ",", "library_name", ",", "library_import_name", ",", "my_caplog", ",", "monkeypatch", ",", ")", ":", "basedir", "=", "tmp_path_factory", ".", "mktemp", "(", "\"test_cli_init_diff\"", ")", "runner", "=", "CliRunner", "(", "mix_stderr", "=", "False", ")", "monkeypatch", ".", "chdir", "(", "basedir", ")", "result", "=", "runner", ".", "invoke", "(", "cli", ",", "[", "\"--v3-api\"", ",", "\"init\"", ",", "\"--no-view\"", "]", ",", "input", "=", "cli_input", ",", "catch_exceptions", "=", "False", ")", "stdout", "=", "result", ".", "output", "print", "(", "stdout", ")", "assert", "\"Always know what to expect from your data\"", "in", "stdout", "assert", "\"What data would you like Great Expectations to connect to\"", "in", "stdout", "assert", "\"Which database backend are you using\"", "in", "stdout", "assert", "\"Give your new Datasource a short name\"", "in", "stdout", "assert", "(", "\"\"\"Next, we will configure database credentials and store them in the `my_db` section\nof this config file: great_expectations/uncommitted/config_variables.yml\"\"\"", "in", "stdout", ")", "assert", "(", "f\"\"\"Great Expectations relies on the library `{library_import_name}` to connect to your data, \\\nbut the package `{library_name}` containing this library is not installed.\n Would you like Great Expectations to try to execute `pip install {library_name}` for you?\"\"\"", "in", "stdout", ")", "assert", "(", "f\"\"\"\\nOK, exiting now.\n - Please execute `pip install {library_name}` before trying again.\"\"\"", "in", "stdout", ")", "assert", "\"Profiling\"", "not", "in", "stdout", "assert", "\"Building\"", "not", "in", "stdout", "assert", "\"Data Docs\"", "not", "in", "stdout", "assert", "\"Great Expectations is now set up\"", "not", "in", "stdout", "assert", "result", ".", "exit_code", "==", "1", "assert", "os", ".", "path", ".", "isdir", "(", "os", ".", "path", ".", "join", "(", "basedir", ",", "\"great_expectations\"", ")", ")", "config_path", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "\"great_expectations/great_expectations.yml\"", ")", "assert", "os", ".", "path", ".", "isfile", "(", "config_path", ")", "config", "=", "yaml", ".", "load", "(", "open", "(", "config_path", ")", ")", "assert", "config", "[", "\"datasources\"", "]", "==", "dict", "(", ")", "obs_tree", "=", "gen_directory_tree_str", "(", "os", ".", "path", ".", "join", "(", "basedir", ",", "\"great_expectations\"", ")", ")", "assert", "(", "obs_tree", "==", "\"\"\"\\\ngreat_expectations/\n .gitignore\n great_expectations.yml\n checkpoints/\n expectations/\n .ge_store_backend_id\n notebooks/\n pandas/\n validation_playground.ipynb\n spark/\n validation_playground.ipynb\n sql/\n validation_playground.ipynb\n plugins/\n custom_data_docs/\n renderers/\n styles/\n data_docs_custom_styles.css\n views/\n uncommitted/\n config_variables.yml\n data_docs/\n validations/\n .ge_store_backend_id\n\"\"\"", ")", "assert_no_logging_messages_or_tracebacks", "(", "my_caplog", ",", "result", ")" ]

[ 14, 0 ]

[ 102, 63 ]

[ "def", "test_init_install_sqlalchemy", "(", "caplog", ",", "tmp_path_factory", ",", "monkeypatch", ")", ":", "# This test is as much about changing the entire test environment with side effects as it is about actually testing", "# the observed behavior.", "library_import_name", "=", "\"sqlalchemy\"", "library_name", "=", "\"sqlalchemy\"", "cli_input", "=", "\"\\n\\n2\\nn\\n\"", "basedir", "=", "tmp_path_factory", ".", "mktemp", "(", "\"test_cli_init_diff\"", ")", "runner", "=", "CliRunner", "(", "mix_stderr", "=", "False", ")", "monkeypatch", ".", "chdir", "(", "basedir", ")", "result", "=", "runner", ".", "invoke", "(", "cli", ",", "[", "\"--v3-api\"", ",", "\"init\"", ",", "\"--no-view\"", "]", ",", "input", "=", "cli_input", ",", "catch_exceptions", "=", "False", ")", "stdout", "=", "result", ".", "output", "assert", "\"Always know what to expect from your data\"", "in", "stdout", "assert", "\"What data would you like Great Expectations to connect to\"", "in", "stdout", "assert", "(", "f\"\"\"Great Expectations relies on the library `{library_import_name}` to connect to your data, \\\nbut the package `{library_name}` containing this library is not installed.\n Would you like Great Expectations to try to execute `pip install {library_name}` for you?\"\"\"", "in", "stdout", ")", "# NOW, IN AN EVIL KNOWN ONLY TO SLEEPLESS PROGRAMMERS, WE USE OUR UTILITY TO INSTALL SQLALCHEMY", "_", "=", "execute_shell_command_with_progress_polling", "(", "\"pip install sqlalchemy\"", ")" ]

[ 114, 0 ]

[ 142, 77 ]

[ "def", "column_map_expectation", "(", "cls", ",", "func", ")", ":", "argspec", "=", "inspect", ".", "getfullargspec", "(", "func", ")", "[", "0", "]", "[", "1", ":", "]", "@", "cls", ".", "expectation", "(", "argspec", ")", "@", "wraps", "(", "func", ")", "def", "inner_wrapper", "(", "self", ",", "column", ",", "mostly", "=", "None", ",", "result_format", "=", "None", ",", "row_condition", "=", "None", ",", "condition_parser", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ",", ")", ":", "if", "result_format", "is", "None", ":", "result_format", "=", "self", ".", "default_expectation_args", "[", "\"result_format\"", "]", "result_format", "=", "parse_result_format", "(", "result_format", ")", "if", "row_condition", "and", "self", ".", "_supports_row_condition", ":", "data", "=", "self", ".", "_apply_row_condition", "(", "row_condition", "=", "row_condition", ",", "condition_parser", "=", "condition_parser", ")", "else", ":", "data", "=", "self", "series", "=", "data", "[", "column", "]", "if", "func", ".", "__name__", "in", "[", "\"expect_column_values_to_not_be_null\"", ",", "\"expect_column_values_to_be_null\"", ",", "]", ":", "# Counting the number of unexpected values can be expensive when there is a large", "# number of np.nan values.", "# This only happens on expect_column_values_to_not_be_null expectations.", "# Since there is no reason to look for most common unexpected values in this case,", "# we will instruct the result formatting method to skip this step.", "# FIXME rename to mapped_ignore_values?", "boolean_mapped_null_values", "=", "np", ".", "full", "(", "series", ".", "shape", ",", "False", ")", "result_format", "[", "\"partial_unexpected_count\"", "]", "=", "0", "else", ":", "boolean_mapped_null_values", "=", "series", ".", "isnull", "(", ")", ".", "values", "element_count", "=", "int", "(", "len", "(", "series", ")", ")", "# FIXME rename nonnull to non_ignored?", "nonnull_values", "=", "series", "[", "boolean_mapped_null_values", "==", "False", "]", "nonnull_count", "=", "int", "(", "(", "boolean_mapped_null_values", "==", "False", ")", ".", "sum", "(", ")", ")", "boolean_mapped_success_values", "=", "func", "(", "self", ",", "nonnull_values", ",", "*", "args", ",", "*", "*", "kwargs", ")", "success_count", "=", "np", ".", "count_nonzero", "(", "boolean_mapped_success_values", ")", "unexpected_list", "=", "list", "(", "nonnull_values", "[", "boolean_mapped_success_values", "==", "False", "]", ")", "unexpected_index_list", "=", "list", "(", "nonnull_values", "[", "boolean_mapped_success_values", "==", "False", "]", ".", "index", ")", "if", "\"output_strftime_format\"", "in", "kwargs", ":", "output_strftime_format", "=", "kwargs", "[", "\"output_strftime_format\"", "]", "parsed_unexpected_list", "=", "[", "]", "for", "val", "in", "unexpected_list", ":", "if", "val", "is", "None", ":", "parsed_unexpected_list", ".", "append", "(", "val", ")", "else", ":", "if", "isinstance", "(", "val", ",", "str", ")", ":", "val", "=", "parse", "(", "val", ")", "parsed_unexpected_list", ".", "append", "(", "datetime", ".", "strftime", "(", "val", ",", "output_strftime_format", ")", ")", "unexpected_list", "=", "parsed_unexpected_list", "success", ",", "percent_success", "=", "self", ".", "_calc_map_expectation_success", "(", "success_count", ",", "nonnull_count", ",", "mostly", ")", "return_obj", "=", "self", ".", "_format_map_output", "(", "result_format", ",", "success", ",", "element_count", ",", "nonnull_count", ",", "len", "(", "unexpected_list", ")", ",", "unexpected_list", ",", "unexpected_index_list", ",", ")", "# FIXME Temp fix for result format", "if", "func", ".", "__name__", "in", "[", "\"expect_column_values_to_not_be_null\"", ",", "\"expect_column_values_to_be_null\"", ",", "]", ":", "del", "return_obj", "[", "\"result\"", "]", "[", "\"unexpected_percent_nonmissing\"", "]", "del", "return_obj", "[", "\"result\"", "]", "[", "\"missing_count\"", "]", "del", "return_obj", "[", "\"result\"", "]", "[", "\"missing_percent\"", "]", "try", ":", "del", "return_obj", "[", "\"result\"", "]", "[", "\"partial_unexpected_counts\"", "]", "del", "return_obj", "[", "\"result\"", "]", "[", "\"partial_unexpected_list\"", "]", "except", "KeyError", ":", "pass", "return", "return_obj", "inner_wrapper", ".", "__name__", "=", "func", ".", "__name__", "inner_wrapper", ".", "__doc__", "=", "func", ".", "__doc__", "return", "inner_wrapper" ]

[ 43, 4 ]

[ 159, 28 ]

[ "def", "column_pair_map_expectation", "(", "cls", ",", "func", ")", ":", "argspec", "=", "inspect", ".", "getfullargspec", "(", "func", ")", "[", "0", "]", "[", "1", ":", "]", "@", "cls", ".", "expectation", "(", "argspec", ")", "@", "wraps", "(", "func", ")", "def", "inner_wrapper", "(", "self", ",", "column_A", ",", "column_B", ",", "mostly", "=", "None", ",", "ignore_row_if", "=", "\"both_values_are_missing\"", ",", "result_format", "=", "None", ",", "row_condition", "=", "None", ",", "condition_parser", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ",", ")", ":", "if", "result_format", "is", "None", ":", "result_format", "=", "self", ".", "default_expectation_args", "[", "\"result_format\"", "]", "if", "row_condition", ":", "self", "=", "self", ".", "query", "(", "row_condition", ")", ".", "reset_index", "(", "drop", "=", "True", ")", "series_A", "=", "self", "[", "column_A", "]", "series_B", "=", "self", "[", "column_B", "]", "if", "ignore_row_if", "==", "\"both_values_are_missing\"", ":", "boolean_mapped_null_values", "=", "series_A", ".", "isnull", "(", ")", "&", "series_B", ".", "isnull", "(", ")", "elif", "ignore_row_if", "==", "\"either_value_is_missing\"", ":", "boolean_mapped_null_values", "=", "series_A", ".", "isnull", "(", ")", "|", "series_B", ".", "isnull", "(", ")", "elif", "ignore_row_if", "==", "\"never\"", ":", "boolean_mapped_null_values", "=", "series_A", ".", "map", "(", "lambda", "x", ":", "False", ")", "else", ":", "raise", "ValueError", "(", "\"Unknown value of ignore_row_if: %s\"", ",", "(", "ignore_row_if", ",", ")", ")", "assert", "len", "(", "series_A", ")", "==", "len", "(", "series_B", ")", ",", "\"Series A and B must be the same length\"", "# This next bit only works if series_A and _B are the same length", "element_count", "=", "int", "(", "len", "(", "series_A", ")", ")", "nonnull_count", "=", "(", "boolean_mapped_null_values", "==", "False", ")", ".", "sum", "(", ")", "nonnull_values_A", "=", "series_A", "[", "boolean_mapped_null_values", "==", "False", "]", "nonnull_values_B", "=", "series_B", "[", "boolean_mapped_null_values", "==", "False", "]", "nonnull_values", "=", "[", "value_pair", "for", "value_pair", "in", "zip", "(", "list", "(", "nonnull_values_A", ")", ",", "list", "(", "nonnull_values_B", ")", ")", "]", "boolean_mapped_success_values", "=", "func", "(", "self", ",", "nonnull_values_A", ",", "nonnull_values_B", ",", "*", "args", ",", "*", "*", "kwargs", ")", "success_count", "=", "boolean_mapped_success_values", ".", "sum", "(", ")", "unexpected_list", "=", "[", "value_pair", "for", "value_pair", "in", "zip", "(", "list", "(", "series_A", "[", "(", "boolean_mapped_success_values", "==", "False", ")", "&", "(", "boolean_mapped_null_values", "==", "False", ")", "]", ")", ",", "list", "(", "series_B", "[", "(", "boolean_mapped_success_values", "==", "False", ")", "&", "(", "boolean_mapped_null_values", "==", "False", ")", "]", ")", ",", ")", "]", "unexpected_index_list", "=", "list", "(", "series_A", "[", "(", "boolean_mapped_success_values", "==", "False", ")", "&", "(", "boolean_mapped_null_values", "==", "False", ")", "]", ".", "index", ")", "success", ",", "percent_success", "=", "self", ".", "_calc_map_expectation_success", "(", "success_count", ",", "nonnull_count", ",", "mostly", ")", "return_obj", "=", "self", ".", "_format_map_output", "(", "result_format", ",", "success", ",", "element_count", ",", "nonnull_count", ",", "len", "(", "unexpected_list", ")", ",", "unexpected_list", ",", "unexpected_index_list", ",", ")", "return", "return_obj", "inner_wrapper", ".", "__name__", "=", "func", ".", "__name__", "inner_wrapper", ".", "__doc__", "=", "func", ".", "__doc__", "return", "inner_wrapper" ]

[ 162, 4 ]

[ 264, 28 ]

[ "def", "multicolumn_map_expectation", "(", "cls", ",", "func", ")", ":", "argspec", "=", "inspect", ".", "getfullargspec", "(", "func", ")", "[", "0", "]", "[", "1", ":", "]", "@", "cls", ".", "expectation", "(", "argspec", ")", "@", "wraps", "(", "func", ")", "def", "inner_wrapper", "(", "self", ",", "column_list", ",", "mostly", "=", "None", ",", "ignore_row_if", "=", "\"all_values_are_missing\"", ",", "result_format", "=", "None", ",", "row_condition", "=", "None", ",", "condition_parser", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ",", ")", ":", "if", "result_format", "is", "None", ":", "result_format", "=", "self", ".", "default_expectation_args", "[", "\"result_format\"", "]", "if", "row_condition", ":", "self", "=", "self", ".", "query", "(", "row_condition", ")", ".", "reset_index", "(", "drop", "=", "True", ")", "test_df", "=", "self", "[", "column_list", "]", "if", "ignore_row_if", "==", "\"all_values_are_missing\"", ":", "boolean_mapped_skip_values", "=", "test_df", ".", "isnull", "(", ")", ".", "all", "(", "axis", "=", "1", ")", "elif", "ignore_row_if", "==", "\"any_value_is_missing\"", ":", "boolean_mapped_skip_values", "=", "test_df", ".", "isnull", "(", ")", ".", "any", "(", "axis", "=", "1", ")", "elif", "ignore_row_if", "==", "\"never\"", ":", "boolean_mapped_skip_values", "=", "pd", ".", "Series", "(", "[", "False", "]", "*", "len", "(", "test_df", ")", ")", "else", ":", "raise", "ValueError", "(", "\"Unknown value of ignore_row_if: %s\"", ",", "(", "ignore_row_if", ",", ")", ")", "boolean_mapped_success_values", "=", "func", "(", "self", ",", "test_df", "[", "boolean_mapped_skip_values", "==", "False", "]", ",", "*", "args", ",", "*", "*", "kwargs", ")", "success_count", "=", "boolean_mapped_success_values", ".", "sum", "(", ")", "nonnull_count", "=", "(", "~", "boolean_mapped_skip_values", ")", ".", "sum", "(", ")", "element_count", "=", "len", "(", "test_df", ")", "unexpected_list", "=", "test_df", "[", "(", "boolean_mapped_skip_values", "==", "False", ")", "&", "(", "boolean_mapped_success_values", "==", "False", ")", "]", "unexpected_index_list", "=", "list", "(", "unexpected_list", ".", "index", ")", "success", ",", "percent_success", "=", "self", ".", "_calc_map_expectation_success", "(", "success_count", ",", "nonnull_count", ",", "mostly", ")", "return_obj", "=", "self", ".", "_format_map_output", "(", "result_format", ",", "success", ",", "element_count", ",", "nonnull_count", ",", "len", "(", "unexpected_list", ")", ",", "unexpected_list", ".", "to_dict", "(", "orient", "=", "\"records\"", ")", ",", "unexpected_index_list", ",", ")", "return", "return_obj", "inner_wrapper", ".", "__name__", "=", "func", ".", "__name__", "inner_wrapper", ".", "__doc__", "=", "func", ".", "__doc__", "return", "inner_wrapper" ]

[ 267, 4 ]

[ 336, 28 ]

[ "def", "get_crosstab", "(", "self", ",", "column_A", ",", "column_B", ",", "bins_A", "=", "None", ",", "bins_B", "=", "None", ",", "n_bins_A", "=", "None", ",", "n_bins_B", "=", "None", ",", ")", ":", "series_A", "=", "self", ".", "get_binned_values", "(", "self", "[", "column_A", "]", ",", "bins_A", ",", "n_bins_A", ")", "series_B", "=", "self", ".", "get_binned_values", "(", "self", "[", "column_B", "]", ",", "bins_B", ",", "n_bins_B", ")", "return", "pd", ".", "crosstab", "(", "series_A", ",", "columns", "=", "series_B", ")" ]

[ 542, 4 ]

[ 554, 54 ]

[ "def", "get_binned_values", "(", "self", ",", "series", ",", "bins", ",", "n_bins", ")", ":", "if", "n_bins", "is", "None", ":", "n_bins", "=", "10", "if", "series", ".", "dtype", "in", "[", "\"int\"", ",", "\"float\"", "]", ":", "if", "bins", "is", "not", "None", ":", "bins", "=", "sorted", "(", "np", ".", "unique", "(", "bins", ")", ")", "if", "np", ".", "min", "(", "series", ")", "<", "bins", "[", "0", "]", ":", "bins", "=", "[", "np", ".", "min", "(", "series", ")", "]", "+", "bins", "if", "np", ".", "max", "(", "series", ")", ">", "bins", "[", "-", "1", "]", ":", "bins", "=", "bins", "+", "[", "np", ".", "max", "(", "series", ")", "]", "if", "bins", "is", "None", ":", "bins", "=", "np", ".", "histogram_bin_edges", "(", "series", "[", "series", ".", "notnull", "(", ")", "]", ",", "bins", "=", "n_bins", ")", "# Make sure max of series is included in rightmost bin", "bins", "[", "-", "1", "]", "=", "np", ".", "nextafter", "(", "bins", "[", "-", "1", "]", ",", "bins", "[", "-", "1", "]", "+", "1", ")", "# Create labels for returned series", "# Used in e.g. crosstab that is printed as observed value in data docs.", "precision", "=", "int", "(", "np", ".", "log10", "(", "min", "(", "bins", "[", "1", ":", "]", "-", "bins", "[", ":", "-", "1", "]", ")", ")", ")", "+", "2", "labels", "=", "[", "f\"[{round(lower, precision)}, {round(upper, precision)})\"", "for", "lower", ",", "upper", "in", "zip", "(", "bins", "[", ":", "-", "1", "]", ",", "bins", "[", "1", ":", "]", ")", "]", "if", "any", "(", "np", ".", "isnan", "(", "series", ")", ")", ":", "# Missing get digitized into bin = n_bins+1", "labels", "+=", "[", "\"(missing)\"", "]", "return", "pd", ".", "Categorical", ".", "from_codes", "(", "codes", "=", "np", ".", "digitize", "(", "series", ",", "bins", "=", "bins", ")", "-", "1", ",", "categories", "=", "labels", ",", "ordered", "=", "True", ",", ")", "else", ":", "if", "bins", "is", "None", ":", "value_counts", "=", "series", ".", "value_counts", "(", "sort", "=", "True", ")", "if", "len", "(", "value_counts", ")", "<", "n_bins", "+", "1", ":", "return", "series", ".", "fillna", "(", "\"(missing)\"", ")", "else", ":", "other_values", "=", "sorted", "(", "value_counts", ".", "index", "[", "n_bins", ":", "]", ")", "replace", "=", "{", "value", ":", "\"(other)\"", "for", "value", "in", "other_values", "}", "else", ":", "replace", "=", "dict", "(", ")", "for", "x", "in", "bins", ":", "replace", ".", "update", "(", "{", "value", ":", "\", \"", ".", "join", "(", "x", ")", "for", "value", "in", "x", "}", ")", "return", "(", "series", ".", "replace", "(", "to_replace", "=", "replace", ")", ".", "fillna", "(", "\"(missing)\"", ")", ".", "astype", "(", "\"category\"", ")", ")" ]

[ 556, 4 ]

[ 617, 13 ]

[ "def", "expect_column_values_to_be_of_type", "(", "self", ",", "column", ",", "type_", ",", "*", "*", "kwargs", "# Since we've now received the default arguments *before* the expectation decorator, we need to", "# ensure we only pass what we actually received. Hence, we'll use kwargs", "# mostly=None,", "# result_format=None,", "# row_condition=None, condition_parser=None, include_config=None, catch_exceptions=None, meta=None", ")", ":", "# Short-circuit if the dtype tells us; in that case use column-aggregate (vs map) semantics", "if", "(", "self", "[", "column", "]", ".", "dtype", "!=", "\"object\"", "or", "type_", "is", "None", "or", "type_", "in", "[", "\"object\"", ",", "\"object_\"", ",", "\"O\"", "]", ")", ":", "res", "=", "self", ".", "_expect_column_values_to_be_of_type__aggregate", "(", "column", ",", "type_", ",", "*", "*", "kwargs", ")", "# Note: this logic is similar to the logic in _append_expectation for deciding when to overwrite an", "# existing expectation, but it should be definitely kept in sync", "# We do not need this bookkeeping if we are in an active validation:", "if", "self", ".", "_active_validation", ":", "return", "res", "# First, if there is an existing expectation of this type, delete it. Then change the one we created to be", "# of the proper expectation_type", "existing_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_of_type\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "if", "len", "(", "existing_expectations", ")", "==", "1", ":", "self", ".", "_expectation_suite", ".", "expectations", ".", "pop", "(", "existing_expectations", "[", "0", "]", ")", "# Now, rename the expectation we just added", "new_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"_expect_column_values_to_be_of_type__aggregate\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "assert", "len", "(", "new_expectations", ")", "==", "1", "old_config", "=", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "new_config", "=", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_of_type\"", ",", "kwargs", "=", "old_config", ".", "kwargs", ",", "meta", "=", "old_config", ".", "meta", ",", "success_on_last_run", "=", "old_config", ".", "success_on_last_run", ",", ")", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "=", "new_config", "else", ":", "res", "=", "self", ".", "_expect_column_values_to_be_of_type__map", "(", "column", ",", "type_", ",", "*", "*", "kwargs", ")", "# Note: this logic is similar to the logic in _append_expectation for deciding when to overwrite an", "# existing expectation, but it should be definitely kept in sync", "# We do not need this bookkeeping if we are in an active validation:", "if", "self", ".", "_active_validation", ":", "return", "res", "# First, if there is an existing expectation of this type, delete it. Then change the one we created to be", "# of the proper expectation_type", "existing_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_of_type\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "if", "len", "(", "existing_expectations", ")", "==", "1", ":", "self", ".", "_expectation_suite", ".", "expectations", ".", "pop", "(", "existing_expectations", "[", "0", "]", ")", "# Now, rename the expectation we just added", "new_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"_expect_column_values_to_be_of_type__map\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "assert", "len", "(", "new_expectations", ")", "==", "1", "old_config", "=", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "new_config", "=", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_of_type\"", ",", "kwargs", "=", "old_config", ".", "kwargs", ",", "meta", "=", "old_config", ".", "meta", ",", "success_on_last_run", "=", "old_config", ".", "success_on_last_run", ",", ")", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "=", "new_config", "return", "res" ]

[ 671, 4 ]

[ 782, 18 ]

[ "def", "expect_column_values_to_be_in_type_list", "(", "self", ",", "column", ",", "type_list", ",", "*", "*", "kwargs", "# Since we've now received the default arguments *before* the expectation decorator, we need to", "# ensure we only pass what we actually received. Hence, we'll use kwargs", "# mostly=None,", "# result_format = None,", "# row_condition=None, condition_parser=None, include_config=None, catch_exceptions=None, meta=None", ")", ":", "# Short-circuit if the dtype tells us; in that case use column-aggregate (vs map) semantics", "if", "self", "[", "column", "]", ".", "dtype", "!=", "\"object\"", "or", "type_list", "is", "None", ":", "res", "=", "self", ".", "_expect_column_values_to_be_in_type_list__aggregate", "(", "column", ",", "type_list", ",", "*", "*", "kwargs", ")", "# Note: this logic is similar to the logic in _append_expectation for deciding when to overwrite an", "# existing expectation, but it should be definitely kept in sync", "# We do not need this bookkeeping if we are in an active validation:", "if", "self", ".", "_active_validation", ":", "return", "res", "# First, if there is an existing expectation of this type, delete it. Then change the one we created to be", "# of the proper expectation_type", "existing_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_in_type_list\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "if", "len", "(", "existing_expectations", ")", "==", "1", ":", "self", ".", "_expectation_suite", ".", "expectations", ".", "pop", "(", "existing_expectations", "[", "0", "]", ")", "new_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"_expect_column_values_to_be_in_type_list__aggregate\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "assert", "len", "(", "new_expectations", ")", "==", "1", "old_config", "=", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "new_config", "=", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_in_type_list\"", ",", "kwargs", "=", "old_config", ".", "kwargs", ",", "meta", "=", "old_config", ".", "meta", ",", "success_on_last_run", "=", "old_config", ".", "success_on_last_run", ",", ")", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "=", "new_config", "else", ":", "res", "=", "self", ".", "_expect_column_values_to_be_in_type_list__map", "(", "column", ",", "type_list", ",", "*", "*", "kwargs", ")", "# Note: this logic is similar to the logic in _append_expectation for deciding when to overwrite an", "# existing expectation, but it should be definitely kept in sync", "# We do not need this bookkeeping if we are in an active validation:", "if", "self", ".", "_active_validation", ":", "return", "res", "# First, if there is an existing expectation of this type, delete it. Then change the one we created to be", "# of the proper expectation_type", "existing_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_in_type_list\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "if", "len", "(", "existing_expectations", ")", "==", "1", ":", "self", ".", "_expectation_suite", ".", "expectations", ".", "pop", "(", "existing_expectations", "[", "0", "]", ")", "# Now, rename the expectation we just added", "new_expectations", "=", "self", ".", "_expectation_suite", ".", "find_expectation_indexes", "(", "ExpectationConfiguration", "(", "expectation_type", "=", "\"_expect_column_values_to_be_in_type_list__map\"", ",", "kwargs", "=", "{", "\"column\"", ":", "column", "}", ",", ")", ")", "assert", "len", "(", "new_expectations", ")", "==", "1", "old_config", "=", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "new_config", "=", "ExpectationConfiguration", "(", "expectation_type", "=", "\"expect_column_values_to_be_in_type_list\"", ",", "kwargs", "=", "old_config", ".", "kwargs", ",", "meta", "=", "old_config", ".", "meta", ",", "success_on_last_run", "=", "old_config", ".", "success_on_last_run", ",", ")", "self", ".", "_expectation_suite", ".", "expectations", "[", "new_expectations", "[", "0", "]", "]", "=", "new_config", "return", "res" ]

[ 899, 4 ]

[ 1007, 18 ]

[ "def", "expect_multicolumn_sum_to_equal", "(", "self", ",", "column_list", ",", "sum_total", ",", "result_format", "=", "None", ",", "include_config", "=", "True", ",", "catch_exceptions", "=", "None", ",", "meta", "=", "None", ",", ")", ":", "return", "column_list", ".", "sum", "(", "axis", "=", "1", ")", "==", "sum_total" ]

[ 1856, 4 ]

[ 1875, 51 ]

[ "def", "from_configuration", "(", "cls", ",", "*", "*", "kwargs", ")", ":", "return", "cls", "(", "*", "*", "kwargs", ")" ]

[ 113, 4 ]

[ 124, 28 ]

[ "def", "build_configuration", "(", "cls", ",", "class_name", ",", "module_name", "=", "\"great_expectations.datasource\"", ",", "data_asset_type", "=", "None", ",", "batch_kwargs_generators", "=", "None", ",", "*", "*", "kwargs", ")", ":", "verify_dynamic_loading_support", "(", "module_name", "=", "module_name", ")", "class_", "=", "load_class", "(", "class_name", "=", "class_name", ",", "module_name", "=", "module_name", ")", "configuration", "=", "class_", ".", "build_configuration", "(", "data_asset_type", "=", "data_asset_type", ",", "batch_kwargs_generators", "=", "batch_kwargs_generators", ",", "*", "*", "kwargs", ")", "return", "configuration" ]

[ 127, 4 ]

[ 156, 28 ]

[ "def", "__init__", "(", "self", ",", "name", ",", "data_context", "=", "None", ",", "data_asset_type", "=", "None", ",", "batch_kwargs_generators", "=", "None", ",", "*", "*", "kwargs", ")", ":", "self", ".", "_data_context", "=", "data_context", "self", ".", "_name", "=", "name", "if", "isinstance", "(", "data_asset_type", ",", "str", ")", ":", "warnings", ".", "warn", "(", "\"String-only configuration for data_asset_type is deprecated. Use module_name and class_name instead.\"", ",", "DeprecationWarning", ",", ")", "self", ".", "_data_asset_type", "=", "data_asset_type", "self", ".", "_datasource_config", "=", "kwargs", "self", ".", "_batch_kwargs_generators", "=", "{", "}", "self", ".", "_datasource_config", "[", "\"data_asset_type\"", "]", "=", "data_asset_type", "if", "batch_kwargs_generators", "is", "not", "None", ":", "self", ".", "_datasource_config", "[", "\"batch_kwargs_generators\"", "]", "=", "batch_kwargs_generators" ]

[ 158, 4 ]

[ 188, 88 ]

[ "def", "name", "(", "self", ")", ":", "return", "self", ".", "_name" ]

[ 191, 4 ]

[ 195, 25 ]

[ "def", "data_context", "(", "self", ")", ":", "return", "self", ".", "_data_context" ]

[ 202, 4 ]

[ 206, 33 ]

[ "def", "_build_generators", "(", "self", ")", ":", "try", ":", "for", "generator", "in", "self", ".", "_datasource_config", "[", "\"batch_kwargs_generators\"", "]", ".", "keys", "(", ")", ":", "self", ".", "get_batch_kwargs_generator", "(", "generator", ")", "except", "KeyError", ":", "pass" ]

[ 208, 4 ]

[ 219, 16 ]