Datasets:

---

monsterapi

/

code_search_net

like 0

Follow

MonsterAPI 14

[ "def", "_getPercentile", "(", "points", ",", "n", ",", "interpolate", "=", "False", ")", ":", "sortedPoints", "=", "sorted", "(", "not_none", "(", "points", ")", ")", "if", "len", "(", "sortedPoints", ")", "==", "0", ":", "return", "None", "fractionalRank", "=", "(", "n", "/", "100.0", ")", "*", "(", "len", "(", "sortedPoints", ")", "+", "1", ")", "rank", "=", "int", "(", "fractionalRank", ")", "rankFraction", "=", "fractionalRank", "-", "rank", "if", "not", "interpolate", ":", "rank", "+=", "int", "(", "math", ".", "ceil", "(", "rankFraction", ")", ")", "if", "rank", "==", "0", ":", "percentile", "=", "sortedPoints", "[", "0", "]", "elif", "rank", "-", "1", "==", "len", "(", "sortedPoints", ")", ":", "percentile", "=", "sortedPoints", "[", "-", "1", "]", "else", ":", "percentile", "=", "sortedPoints", "[", "rank", "-", "1", "]", "# Adjust for 0-index", "if", "interpolate", ":", "if", "rank", "!=", "len", "(", "sortedPoints", ")", ":", "# if a next value exists", "nextValue", "=", "sortedPoints", "[", "rank", "]", "percentile", "=", "percentile", "+", "rankFraction", "*", "(", "nextValue", "-", "percentile", ")", "return", "percentile" ]

[ "Percentile", "is", "calculated", "using", "the", "method", "outlined", "in", "the", "NIST", "Engineering", "Statistics", "Handbook", ":", "http", ":", "//", "www", ".", "itl", ".", "nist", ".", "gov", "/", "div898", "/", "handbook", "/", "prc", "/", "section2", "/", "prc252", ".", "htm" ]

[ "def", "nPercentile", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "assert", "n", ",", "'The requested percent is required to be greater than 0'", "results", "=", "[", "]", "for", "s", "in", "seriesList", ":", "# Create a sorted copy of the TimeSeries excluding None values in the", "# values list.", "s_copy", "=", "TimeSeries", "(", "s", ".", "name", ",", "s", ".", "start", ",", "s", ".", "end", ",", "s", ".", "step", ",", "sorted", "(", "not_none", "(", "s", ")", ")", ")", "if", "not", "s_copy", ":", "continue", "# Skip this series because it is empty.", "perc_val", "=", "_getPercentile", "(", "s_copy", ",", "n", ")", "if", "perc_val", "is", "not", "None", ":", "name", "=", "'nPercentile(%s, %g)'", "%", "(", "s_copy", ".", "name", ",", "n", ")", "point_count", "=", "int", "(", "(", "s", ".", "end", "-", "s", ".", "start", ")", "/", "s", ".", "step", ")", "perc_series", "=", "TimeSeries", "(", "name", ",", "s_copy", ".", "start", ",", "s_copy", ".", "end", ",", "s_copy", ".", "step", ",", "[", "perc_val", "]", "*", "point_count", ")", "perc_series", ".", "pathExpression", "=", "name", "results", ".", "append", "(", "perc_series", ")", "return", "results" ]

[ "Returns", "n", "-", "percent", "of", "each", "series", "in", "the", "seriesList", "." ]

[ "def", "averageOutsidePercentile", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "averages", "=", "[", "safeAvg", "(", "s", ")", "for", "s", "in", "seriesList", "]", "if", "n", "<", "50", ":", "n", "=", "100", "-", "n", "lowPercentile", "=", "_getPercentile", "(", "averages", ",", "100", "-", "n", ")", "highPercentile", "=", "_getPercentile", "(", "averages", ",", "n", ")", "return", "[", "s", "for", "s", "in", "seriesList", "if", "not", "lowPercentile", "<", "safeAvg", "(", "s", ")", "<", "highPercentile", "]" ]

[ "Removes", "functions", "lying", "inside", "an", "average", "percentile", "interval" ]

[ "def", "removeBetweenPercentile", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "if", "n", "<", "50", ":", "n", "=", "100", "-", "n", "transposed", "=", "list", "(", "zip_longest", "(", "*", "seriesList", ")", ")", "lowPercentiles", "=", "[", "_getPercentile", "(", "col", ",", "100", "-", "n", ")", "for", "col", "in", "transposed", "]", "highPercentiles", "=", "[", "_getPercentile", "(", "col", ",", "n", ")", "for", "col", "in", "transposed", "]", "return", "[", "l", "for", "l", "in", "seriesList", "if", "sum", "(", "[", "not", "lowPercentiles", "[", "index", "]", "<", "val", "<", "highPercentiles", "[", "index", "]", "for", "index", ",", "val", "in", "enumerate", "(", "l", ")", "]", ")", ">", "0", "]" ]

[ "Removes", "lines", "who", "do", "not", "have", "an", "value", "lying", "in", "the", "x", "-", "percentile", "of", "all", "the", "values", "at", "a", "moment" ]

[ "def", "removeAboveValue", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "for", "s", "in", "seriesList", ":", "s", ".", "name", "=", "'removeAboveValue(%s, %g)'", "%", "(", "s", ".", "name", ",", "n", ")", "s", ".", "pathExpression", "=", "s", ".", "name", "for", "(", "index", ",", "val", ")", "in", "enumerate", "(", "s", ")", ":", "if", "val", "is", "None", ":", "continue", "if", "val", ">", "n", ":", "s", "[", "index", "]", "=", "None", "return", "seriesList" ]

[ "Removes", "data", "above", "the", "given", "threshold", "from", "the", "series", "or", "list", "of", "series", "provided", ".", "Values", "above", "this", "threshold", "are", "assigned", "a", "value", "of", "None", "." ]

[ "def", "removeBelowPercentile", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "for", "s", "in", "seriesList", ":", "s", ".", "name", "=", "'removeBelowPercentile(%s, %g)'", "%", "(", "s", ".", "name", ",", "n", ")", "s", ".", "pathExpression", "=", "s", ".", "name", "try", ":", "percentile", "=", "nPercentile", "(", "requestContext", ",", "[", "s", "]", ",", "n", ")", "[", "0", "]", "[", "0", "]", "except", "IndexError", ":", "continue", "for", "(", "index", ",", "val", ")", "in", "enumerate", "(", "s", ")", ":", "if", "val", "is", "None", ":", "continue", "if", "val", "<", "percentile", ":", "s", "[", "index", "]", "=", "None", "return", "seriesList" ]

[ "Removes", "data", "below", "the", "nth", "percentile", "from", "the", "series", "or", "list", "of", "series", "provided", ".", "Values", "below", "this", "percentile", "are", "assigned", "a", "value", "of", "None", "." ]

[ "def", "sortByName", "(", "requestContext", ",", "seriesList", ",", "natural", "=", "False", ")", ":", "if", "natural", ":", "return", "list", "(", "sorted", "(", "seriesList", ",", "key", "=", "lambda", "x", ":", "paddedName", "(", "x", ".", "name", ")", ")", ")", "else", ":", "return", "list", "(", "sorted", "(", "seriesList", ",", "key", "=", "lambda", "x", ":", "x", ".", "name", ")", ")" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "." ]

[ "def", "sortByTotal", "(", "requestContext", ",", "seriesList", ")", ":", "return", "list", "(", "sorted", "(", "seriesList", ",", "key", "=", "safeSum", ",", "reverse", "=", "True", ")", ")" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "." ]

[ "def", "useSeriesAbove", "(", "requestContext", ",", "seriesList", ",", "value", ",", "search", ",", "replace", ")", ":", "newSeries", "=", "[", "]", "for", "series", "in", "seriesList", ":", "newname", "=", "re", ".", "sub", "(", "search", ",", "replace", ",", "series", ".", "name", ")", "if", "safeMax", "(", "series", ")", ">", "value", ":", "n", "=", "evaluateTarget", "(", "requestContext", ",", "newname", ")", "if", "n", "is", "not", "None", "and", "len", "(", "n", ")", ">", "0", ":", "newSeries", ".", "append", "(", "n", "[", "0", "]", ")", "return", "newSeries" ]

[ "Compares", "the", "maximum", "of", "each", "series", "against", "the", "given", "value", ".", "If", "the", "series", "maximum", "is", "greater", "than", "value", "the", "regular", "expression", "search", "and", "replace", "is", "applied", "against", "the", "series", "name", "to", "plot", "a", "related", "metric", "." ]

[ "def", "mostDeviant", "(", "requestContext", ",", "seriesList", ",", "n", ")", ":", "deviants", "=", "[", "]", "for", "series", "in", "seriesList", ":", "mean", "=", "safeAvg", "(", "series", ")", "if", "mean", "is", "None", ":", "continue", "square_sum", "=", "sum", "(", "[", "(", "value", "-", "mean", ")", "**", "2", "for", "value", "in", "series", "if", "value", "is", "not", "None", "]", ")", "sigma", "=", "safeDiv", "(", "square_sum", ",", "safeLen", "(", "series", ")", ")", "if", "sigma", "is", "None", ":", "continue", "deviants", ".", "append", "(", "(", "sigma", ",", "series", ")", ")", "return", "[", "series", "for", "sig", ",", "series", "in", "sorted", "(", "deviants", ",", "# sort by sigma", "key", "=", "itemgetter", "(", "0", ")", ",", "reverse", "=", "True", ")", "]", "[", ":", "n", "]" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "an", "integer", "N", ".", "Draws", "the", "N", "most", "deviant", "metrics", ".", "To", "find", "the", "deviants", "the", "standard", "deviation", "(", "sigma", ")", "of", "each", "series", "is", "taken", "and", "ranked", ".", "The", "top", "N", "standard", "deviations", "are", "returned", "." ]

[ "def", "stdev", "(", "requestContext", ",", "seriesList", ",", "points", ",", "windowTolerance", "=", "0.1", ")", ":", "# For this we take the standard deviation in terms of the moving average", "# and the moving average of series squares.", "for", "seriesIndex", ",", "series", "in", "enumerate", "(", "seriesList", ")", ":", "stdevSeries", "=", "TimeSeries", "(", "\"stdev(%s,%d)\"", "%", "(", "series", ".", "name", ",", "int", "(", "points", ")", ")", ",", "series", ".", "start", ",", "series", ".", "end", ",", "series", ".", "step", ",", "[", "]", ")", "stdevSeries", ".", "pathExpression", "=", "\"stdev(%s,%d)\"", "%", "(", "series", ".", "name", ",", "int", "(", "points", ")", ")", "validPoints", "=", "0", "currentSum", "=", "0", "currentSumOfSquares", "=", "0", "for", "index", ",", "newValue", "in", "enumerate", "(", "series", ")", ":", "# Mark whether we've reached our window size - dont drop points", "# out otherwise", "if", "index", "<", "points", ":", "bootstrapping", "=", "True", "droppedValue", "=", "None", "else", ":", "bootstrapping", "=", "False", "droppedValue", "=", "series", "[", "index", "-", "points", "]", "# Track non-None points in window", "if", "not", "bootstrapping", "and", "droppedValue", "is", "not", "None", ":", "validPoints", "-=", "1", "if", "newValue", "is", "not", "None", ":", "validPoints", "+=", "1", "# Remove the value that just dropped out of the window", "if", "not", "bootstrapping", "and", "droppedValue", "is", "not", "None", ":", "currentSum", "-=", "droppedValue", "currentSumOfSquares", "-=", "droppedValue", "**", "2", "# Add in the value that just popped in the window", "if", "newValue", "is", "not", "None", ":", "currentSum", "+=", "newValue", "currentSumOfSquares", "+=", "newValue", "**", "2", "if", "(", "validPoints", ">", "0", "and", "float", "(", "validPoints", ")", "/", "points", ">=", "windowTolerance", ")", ":", "try", ":", "deviation", "=", "math", ".", "sqrt", "(", "validPoints", "*", "currentSumOfSquares", "-", "currentSum", "**", "2", ")", "/", "validPoints", "except", "ValueError", ":", "deviation", "=", "None", "stdevSeries", ".", "append", "(", "deviation", ")", "else", ":", "stdevSeries", ".", "append", "(", "None", ")", "seriesList", "[", "seriesIndex", "]", "=", "stdevSeries", "return", "seriesList" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "an", "integer", "N", ".", "Draw", "the", "Standard", "Deviation", "of", "all", "metrics", "passed", "for", "the", "past", "N", "datapoints", ".", "If", "the", "ratio", "of", "null", "points", "in", "the", "window", "is", "greater", "than", "windowTolerance", "skip", "the", "calculation", ".", "The", "default", "for", "windowTolerance", "is", "0", ".", "1", "(", "up", "to", "10%", "of", "points", "in", "the", "window", "can", "be", "missing", ")", ".", "Note", "that", "if", "this", "is", "set", "to", "0", ".", "0", "it", "will", "cause", "large", "gaps", "in", "the", "output", "anywhere", "a", "single", "point", "is", "missing", "." ]

[ "def", "secondYAxis", "(", "requestContext", ",", "seriesList", ")", ":", "for", "series", "in", "seriesList", ":", "series", ".", "options", "[", "'secondYAxis'", "]", "=", "True", "series", ".", "name", "=", "'secondYAxis(%s)'", "%", "series", ".", "name", "return", "seriesList" ]

[ "Graph", "the", "series", "on", "the", "secondary", "Y", "axis", "." ]

[ "def", "holtWintersForecast", "(", "requestContext", ",", "seriesList", ")", ":", "previewSeconds", "=", "7", "*", "86400", "# 7 days", "# ignore original data and pull new, including our preview", "newContext", "=", "requestContext", ".", "copy", "(", ")", "newContext", "[", "'startTime'", "]", "=", "(", "requestContext", "[", "'startTime'", "]", "-", "timedelta", "(", "seconds", "=", "previewSeconds", ")", ")", "previewList", "=", "evaluateTokens", "(", "newContext", ",", "requestContext", "[", "'args'", "]", "[", "0", "]", ")", "results", "=", "[", "]", "for", "series", "in", "previewList", ":", "analysis", "=", "holtWintersAnalysis", "(", "series", ")", "predictions", "=", "analysis", "[", "'predictions'", "]", "windowPoints", "=", "previewSeconds", "//", "predictions", ".", "step", "result", "=", "TimeSeries", "(", "\"holtWintersForecast(%s)\"", "%", "series", ".", "name", ",", "predictions", ".", "start", "+", "previewSeconds", ",", "predictions", ".", "end", ",", "predictions", ".", "step", ",", "predictions", "[", "windowPoints", ":", "]", ")", "result", ".", "pathExpression", "=", "result", ".", "name", "results", ".", "append", "(", "result", ")", "return", "results" ]

[ "Performs", "a", "Holt", "-", "Winters", "forecast", "using", "the", "series", "as", "input", "data", ".", "Data", "from", "one", "week", "previous", "to", "the", "series", "is", "used", "to", "bootstrap", "the", "initial", "forecast", "." ]

[ "def", "holtWintersConfidenceBands", "(", "requestContext", ",", "seriesList", ",", "delta", "=", "3", ")", ":", "previewSeconds", "=", "7", "*", "86400", "# 7 days", "# ignore original data and pull new, including our preview", "newContext", "=", "requestContext", ".", "copy", "(", ")", "newContext", "[", "'startTime'", "]", "=", "(", "requestContext", "[", "'startTime'", "]", "-", "timedelta", "(", "seconds", "=", "previewSeconds", ")", ")", "previewList", "=", "evaluateTokens", "(", "newContext", ",", "requestContext", "[", "'args'", "]", "[", "0", "]", ")", "results", "=", "[", "]", "for", "series", "in", "previewList", ":", "analysis", "=", "holtWintersAnalysis", "(", "series", ")", "data", "=", "analysis", "[", "'predictions'", "]", "windowPoints", "=", "previewSeconds", "//", "data", ".", "step", "forecast", "=", "TimeSeries", "(", "data", ".", "name", ",", "data", ".", "start", "+", "previewSeconds", ",", "data", ".", "end", ",", "data", ".", "step", ",", "data", "[", "windowPoints", ":", "]", ")", "forecast", ".", "pathExpression", "=", "data", ".", "pathExpression", "data", "=", "analysis", "[", "'deviations'", "]", "windowPoints", "=", "previewSeconds", "//", "data", ".", "step", "deviation", "=", "TimeSeries", "(", "data", ".", "name", ",", "data", ".", "start", "+", "previewSeconds", ",", "data", ".", "end", ",", "data", ".", "step", ",", "data", "[", "windowPoints", ":", "]", ")", "deviation", ".", "pathExpression", "=", "data", ".", "pathExpression", "seriesLength", "=", "len", "(", "forecast", ")", "i", "=", "0", "upperBand", "=", "list", "(", ")", "lowerBand", "=", "list", "(", ")", "while", "i", "<", "seriesLength", ":", "forecast_item", "=", "forecast", "[", "i", "]", "deviation_item", "=", "deviation", "[", "i", "]", "i", "=", "i", "+", "1", "if", "forecast_item", "is", "None", "or", "deviation_item", "is", "None", ":", "upperBand", ".", "append", "(", "None", ")", "lowerBand", ".", "append", "(", "None", ")", "else", ":", "scaled_deviation", "=", "delta", "*", "deviation_item", "upperBand", ".", "append", "(", "forecast_item", "+", "scaled_deviation", ")", "lowerBand", ".", "append", "(", "forecast_item", "-", "scaled_deviation", ")", "upperName", "=", "\"holtWintersConfidenceUpper(%s)\"", "%", "series", ".", "name", "lowerName", "=", "\"holtWintersConfidenceLower(%s)\"", "%", "series", ".", "name", "upperSeries", "=", "TimeSeries", "(", "upperName", ",", "forecast", ".", "start", ",", "forecast", ".", "end", ",", "forecast", ".", "step", ",", "upperBand", ")", "lowerSeries", "=", "TimeSeries", "(", "lowerName", ",", "forecast", ".", "start", ",", "forecast", ".", "end", ",", "forecast", ".", "step", ",", "lowerBand", ")", "upperSeries", ".", "pathExpression", "=", "series", ".", "pathExpression", "lowerSeries", ".", "pathExpression", "=", "series", ".", "pathExpression", "results", ".", "append", "(", "lowerSeries", ")", "results", ".", "append", "(", "upperSeries", ")", "return", "results" ]

[ "Performs", "a", "Holt", "-", "Winters", "forecast", "using", "the", "series", "as", "input", "data", "and", "plots", "upper", "and", "lower", "bands", "with", "the", "predicted", "forecast", "deviations", "." ]

[ "def", "holtWintersAberration", "(", "requestContext", ",", "seriesList", ",", "delta", "=", "3", ")", ":", "results", "=", "[", "]", "for", "series", "in", "seriesList", ":", "confidenceBands", "=", "holtWintersConfidenceBands", "(", "requestContext", ",", "[", "series", "]", ",", "delta", ")", "lowerBand", "=", "confidenceBands", "[", "0", "]", "upperBand", "=", "confidenceBands", "[", "1", "]", "aberration", "=", "list", "(", ")", "for", "i", ",", "actual", "in", "enumerate", "(", "series", ")", ":", "if", "actual", "is", "None", ":", "aberration", ".", "append", "(", "0", ")", "elif", "upperBand", "[", "i", "]", "is", "not", "None", "and", "actual", ">", "upperBand", "[", "i", "]", ":", "aberration", ".", "append", "(", "actual", "-", "upperBand", "[", "i", "]", ")", "elif", "lowerBand", "[", "i", "]", "is", "not", "None", "and", "actual", "<", "lowerBand", "[", "i", "]", ":", "aberration", ".", "append", "(", "actual", "-", "lowerBand", "[", "i", "]", ")", "else", ":", "aberration", ".", "append", "(", "0", ")", "newName", "=", "\"holtWintersAberration(%s)\"", "%", "series", ".", "name", "results", ".", "append", "(", "TimeSeries", "(", "newName", ",", "series", ".", "start", ",", "series", ".", "end", ",", "series", ".", "step", ",", "aberration", ")", ")", "return", "results" ]

[ "Performs", "a", "Holt", "-", "Winters", "forecast", "using", "the", "series", "as", "input", "data", "and", "plots", "the", "positive", "or", "negative", "deviation", "of", "the", "series", "data", "from", "the", "forecast", "." ]

[ "def", "holtWintersConfidenceArea", "(", "requestContext", ",", "seriesList", ",", "delta", "=", "3", ")", ":", "bands", "=", "holtWintersConfidenceBands", "(", "requestContext", ",", "seriesList", ",", "delta", ")", "results", "=", "areaBetween", "(", "requestContext", ",", "bands", ")", "for", "series", "in", "results", ":", "series", ".", "name", "=", "series", ".", "name", ".", "replace", "(", "'areaBetween'", ",", "'holtWintersConfidenceArea'", ")", "return", "results" ]

[ "Performs", "a", "Holt", "-", "Winters", "forecast", "using", "the", "series", "as", "input", "data", "and", "plots", "the", "area", "between", "the", "upper", "and", "lower", "bands", "of", "the", "predicted", "forecast", "deviations", "." ]

[ "def", "linearRegressionAnalysis", "(", "series", ")", ":", "n", "=", "safeLen", "(", "series", ")", "sumI", "=", "sum", "(", "[", "i", "for", "i", ",", "v", "in", "enumerate", "(", "series", ")", "if", "v", "is", "not", "None", "]", ")", "sumV", "=", "sum", "(", "[", "v", "for", "i", ",", "v", "in", "enumerate", "(", "series", ")", "if", "v", "is", "not", "None", "]", ")", "sumII", "=", "sum", "(", "[", "i", "*", "i", "for", "i", ",", "v", "in", "enumerate", "(", "series", ")", "if", "v", "is", "not", "None", "]", ")", "sumIV", "=", "sum", "(", "[", "i", "*", "v", "for", "i", ",", "v", "in", "enumerate", "(", "series", ")", "if", "v", "is", "not", "None", "]", ")", "denominator", "=", "float", "(", "n", "*", "sumII", "-", "sumI", "*", "sumI", ")", "if", "denominator", "==", "0", ":", "return", "None", "else", ":", "factor", "=", "(", "n", "*", "sumIV", "-", "sumI", "*", "sumV", ")", "/", "denominator", "/", "series", ".", "step", "offset", "=", "sumII", "*", "sumV", "-", "sumIV", "*", "sumI", "offset", "=", "offset", "/", "denominator", "-", "factor", "*", "series", ".", "start", "return", "factor", ",", "offset" ]

[ "Returns", "factor", "and", "offset", "of", "linear", "regression", "function", "by", "least", "squares", "method", "." ]

[ "def", "linearRegression", "(", "requestContext", ",", "seriesList", ",", "startSourceAt", "=", "None", ",", "endSourceAt", "=", "None", ")", ":", "from", ".", "app", "import", "evaluateTarget", "results", "=", "[", "]", "sourceContext", "=", "requestContext", ".", "copy", "(", ")", "if", "startSourceAt", "is", "not", "None", ":", "sourceContext", "[", "'startTime'", "]", "=", "parseATTime", "(", "startSourceAt", ")", "if", "endSourceAt", "is", "not", "None", ":", "sourceContext", "[", "'endTime'", "]", "=", "parseATTime", "(", "endSourceAt", ")", "sourceList", "=", "[", "]", "for", "series", "in", "seriesList", ":", "source", "=", "evaluateTarget", "(", "sourceContext", ",", "series", ".", "pathExpression", ")", "sourceList", ".", "extend", "(", "source", ")", "for", "source", ",", "series", "in", "zip", "(", "sourceList", ",", "seriesList", ")", ":", "newName", "=", "'linearRegression(%s, %s, %s)'", "%", "(", "series", ".", "name", ",", "int", "(", "epoch", "(", "sourceContext", "[", "'startTime'", "]", ")", ")", ",", "int", "(", "epoch", "(", "sourceContext", "[", "'endTime'", "]", ")", ")", ")", "forecast", "=", "linearRegressionAnalysis", "(", "source", ")", "if", "forecast", "is", "None", ":", "continue", "factor", ",", "offset", "=", "forecast", "values", "=", "[", "offset", "+", "(", "series", ".", "start", "+", "i", "*", "series", ".", "step", ")", "*", "factor", "for", "i", "in", "range", "(", "len", "(", "series", ")", ")", "]", "newSeries", "=", "TimeSeries", "(", "newName", ",", "series", ".", "start", ",", "series", ".", "end", ",", "series", ".", "step", ",", "values", ")", "newSeries", ".", "pathExpression", "=", "newSeries", ".", "name", "results", ".", "append", "(", "newSeries", ")", "return", "results" ]

[ "Graphs", "the", "liner", "regression", "function", "by", "least", "squares", "method", "." ]

[ "def", "drawAsInfinite", "(", "requestContext", ",", "seriesList", ")", ":", "for", "series", "in", "seriesList", ":", "series", ".", "options", "[", "'drawAsInfinite'", "]", "=", "True", "series", ".", "name", "=", "'drawAsInfinite(%s)'", "%", "series", ".", "name", "return", "seriesList" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", ".", "If", "the", "value", "is", "zero", "draw", "the", "line", "at", "0", ".", "If", "the", "value", "is", "above", "zero", "draw", "the", "line", "at", "infinity", ".", "If", "the", "value", "is", "null", "or", "less", "than", "zero", "do", "not", "draw", "the", "line", "." ]

[ "def", "lineWidth", "(", "requestContext", ",", "seriesList", ",", "width", ")", ":", "for", "series", "in", "seriesList", ":", "series", ".", "options", "[", "'lineWidth'", "]", "=", "width", "return", "seriesList" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "a", "float", "F", "." ]

[ "def", "dashed", "(", "requestContext", ",", "seriesList", ",", "dashLength", "=", "5", ")", ":", "for", "series", "in", "seriesList", ":", "series", ".", "name", "=", "'dashed(%s, %g)'", "%", "(", "series", ".", "name", ",", "dashLength", ")", "series", ".", "options", "[", "'dashed'", "]", "=", "dashLength", "return", "seriesList" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "a", "float", "F", "." ]

[ "def", "timeStack", "(", "requestContext", ",", "seriesList", ",", "timeShiftUnit", ",", "timeShiftStart", ",", "timeShiftEnd", ")", ":", "# Default to negative. parseTimeOffset defaults to +", "if", "timeShiftUnit", "[", "0", "]", ".", "isdigit", "(", ")", ":", "timeShiftUnit", "=", "'-'", "+", "timeShiftUnit", "delta", "=", "parseTimeOffset", "(", "timeShiftUnit", ")", "# if len(seriesList) > 1, they will all have the same pathExpression,", "# which is all we care about.", "series", "=", "seriesList", "[", "0", "]", "results", "=", "[", "]", "timeShiftStartint", "=", "int", "(", "timeShiftStart", ")", "timeShiftEndint", "=", "int", "(", "timeShiftEnd", ")", "for", "shft", "in", "range", "(", "timeShiftStartint", ",", "timeShiftEndint", ")", ":", "myContext", "=", "requestContext", ".", "copy", "(", ")", "innerDelta", "=", "delta", "*", "shft", "myContext", "[", "'startTime'", "]", "=", "requestContext", "[", "'startTime'", "]", "+", "innerDelta", "myContext", "[", "'endTime'", "]", "=", "requestContext", "[", "'endTime'", "]", "+", "innerDelta", "for", "shiftedSeries", "in", "evaluateTarget", "(", "myContext", ",", "series", ".", "pathExpression", ")", ":", "shiftedSeries", ".", "name", "=", "'timeShift(%s, %s, %s)'", "%", "(", "shiftedSeries", ".", "name", ",", "timeShiftUnit", ",", "shft", ")", "shiftedSeries", ".", "pathExpression", "=", "shiftedSeries", ".", "name", "shiftedSeries", ".", "start", "=", "series", ".", "start", "shiftedSeries", ".", "end", "=", "series", ".", "end", "results", ".", "append", "(", "shiftedSeries", ")", "return", "results" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "a", "quoted", "string", "with", "the", "length", "of", "time", "(", "See", "from", "/", "until", "in", "the", "render", "\\", "_api_", "for", "examples", "of", "time", "formats", ")", ".", "Also", "takes", "a", "start", "multiplier", "and", "end", "multiplier", "for", "the", "length", "of", "time", "-" ]

[ "def", "timeShift", "(", "requestContext", ",", "seriesList", ",", "timeShift", ",", "resetEnd", "=", "True", ",", "alignDST", "=", "False", ")", ":", "# Default to negative. parseTimeOffset defaults to +", "if", "timeShift", "[", "0", "]", ".", "isdigit", "(", ")", ":", "timeShift", "=", "'-'", "+", "timeShift", "delta", "=", "parseTimeOffset", "(", "timeShift", ")", "myContext", "=", "requestContext", ".", "copy", "(", ")", "myContext", "[", "'startTime'", "]", "=", "requestContext", "[", "'startTime'", "]", "+", "delta", "myContext", "[", "'endTime'", "]", "=", "requestContext", "[", "'endTime'", "]", "+", "delta", "if", "alignDST", ":", "reqStartDST", "=", "localDST", "(", "requestContext", "[", "'startTime'", "]", ")", "reqEndDST", "=", "localDST", "(", "requestContext", "[", "'endTime'", "]", ")", "myStartDST", "=", "localDST", "(", "myContext", "[", "'startTime'", "]", ")", "myEndDST", "=", "localDST", "(", "myContext", "[", "'endTime'", "]", ")", "dstOffset", "=", "timedelta", "(", "hours", "=", "0", ")", "# If the requestContext is entirely in DST, and we are entirely", "# NOT in DST", "if", "(", "(", "reqStartDST", "and", "reqEndDST", ")", "and", "(", "not", "myStartDST", "and", "not", "myEndDST", ")", ")", ":", "dstOffset", "=", "timedelta", "(", "hours", "=", "1", ")", "# Or if the requestContext is entirely NOT in DST, and we are", "# entirely in DST", "elif", "(", "(", "not", "reqStartDST", "and", "not", "reqEndDST", ")", "and", "(", "myStartDST", "and", "myEndDST", ")", ")", ":", "dstOffset", "=", "timedelta", "(", "hours", "=", "-", "1", ")", "# Otherwise, we don't do anything, because it would be visually", "# confusing", "myContext", "[", "'startTime'", "]", "+=", "dstOffset", "myContext", "[", "'endTime'", "]", "+=", "dstOffset", "results", "=", "[", "]", "if", "not", "seriesList", ":", "return", "results", "# if len(seriesList) > 1, they will all have the same pathExpression,", "# which is all we care about.", "series", "=", "seriesList", "[", "0", "]", "for", "shiftedSeries", "in", "evaluateTarget", "(", "myContext", ",", "series", ".", "pathExpression", ")", ":", "shiftedSeries", ".", "name", "=", "'timeShift(%s, %s)'", "%", "(", "shiftedSeries", ".", "name", ",", "timeShift", ")", "if", "resetEnd", ":", "shiftedSeries", ".", "end", "=", "series", ".", "end", "else", ":", "shiftedSeries", ".", "end", "=", "(", "shiftedSeries", ".", "end", "-", "shiftedSeries", ".", "start", "+", "series", ".", "start", ")", "shiftedSeries", ".", "start", "=", "series", ".", "start", "results", ".", "append", "(", "shiftedSeries", ")", "return", "results" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "a", "quoted", "string", "with", "the", "length", "of", "time", "(", "See", "from", "/", "until", "in", "the", "render", "\\", "_api_", "for", "examples", "of", "time", "formats", ")", "." ]

[ "def", "timeSlice", "(", "requestContext", ",", "seriesList", ",", "startSliceAt", ",", "endSliceAt", "=", "'now'", ")", ":", "results", "=", "[", "]", "start", "=", "epoch", "(", "parseATTime", "(", "startSliceAt", ")", ")", "end", "=", "epoch", "(", "parseATTime", "(", "endSliceAt", ")", ")", "for", "slicedSeries", "in", "seriesList", ":", "slicedSeries", ".", "name", "=", "'timeSlice(%s, %s, %s)'", "%", "(", "slicedSeries", ".", "name", ",", "int", "(", "start", ")", ",", "int", "(", "end", ")", ")", "curr", "=", "epoch", "(", "requestContext", "[", "\"startTime\"", "]", ")", "for", "i", ",", "v", "in", "enumerate", "(", "slicedSeries", ")", ":", "if", "v", "is", "None", "or", "curr", "<", "start", "or", "curr", ">", "end", ":", "slicedSeries", "[", "i", "]", "=", "None", "curr", "+=", "slicedSeries", ".", "step", "results", ".", "append", "(", "slicedSeries", ")", "return", "results" ]

[ "Takes", "one", "metric", "or", "a", "wildcard", "metric", "followed", "by", "a", "quoted", "string", "with", "the", "time", "to", "start", "the", "line", "and", "another", "quoted", "string", "with", "the", "time", "to", "end", "the", "line", ".", "The", "start", "and", "end", "times", "are", "inclusive", ".", "See", "from", "/", "until", "in", "the", "render", "api", "for", "examples", "of", "time", "formats", "." ]

[ "def", "constantLine", "(", "requestContext", ",", "value", ")", ":", "name", "=", "\"constantLine(%s)\"", "%", "str", "(", "value", ")", "start", "=", "int", "(", "epoch", "(", "requestContext", "[", "'startTime'", "]", ")", ")", "end", "=", "int", "(", "epoch", "(", "requestContext", "[", "'endTime'", "]", ")", ")", "step", "=", "int", "(", "(", "end", "-", "start", ")", "/", "2.0", ")", "series", "=", "TimeSeries", "(", "str", "(", "value", ")", ",", "start", ",", "end", ",", "step", ",", "[", "value", ",", "value", ",", "value", "]", ")", "series", ".", "pathExpression", "=", "name", "return", "[", "series", "]" ]

[ "Takes", "a", "float", "F", "." ]

[ "def", "aggregateLine", "(", "requestContext", ",", "seriesList", ",", "func", "=", "'avg'", ")", ":", "t_funcs", "=", "{", "'avg'", ":", "safeAvg", ",", "'min'", ":", "safeMin", ",", "'max'", ":", "safeMax", "}", "if", "func", "not", "in", "t_funcs", ":", "raise", "ValueError", "(", "\"Invalid function %s\"", "%", "func", ")", "results", "=", "[", "]", "for", "series", "in", "seriesList", ":", "value", "=", "t_funcs", "[", "func", "]", "(", "series", ")", "if", "value", "is", "not", "None", ":", "name", "=", "'aggregateLine(%s, %g)'", "%", "(", "series", ".", "name", ",", "value", ")", "else", ":", "name", "=", "'aggregateLine(%s, None)'", "%", "(", "series", ".", "name", ")", "[", "series", "]", "=", "constantLine", "(", "requestContext", ",", "value", ")", "series", ".", "name", "=", "name", "series", ".", "pathExpression", "=", "series", ".", "name", "results", ".", "append", "(", "series", ")", "return", "results" ]

[ "Takes", "a", "metric", "or", "wildcard", "seriesList", "and", "draws", "a", "horizontal", "line", "based", "on", "the", "function", "applied", "to", "each", "series", "." ]

[ "def", "verticalLine", "(", "requestContext", ",", "ts", ",", "label", "=", "None", ",", "color", "=", "None", ")", ":", "ts", "=", "int", "(", "epoch", "(", "parseATTime", "(", "ts", ",", "requestContext", "[", "'tzinfo'", "]", ")", ")", ")", "start", "=", "int", "(", "epoch", "(", "requestContext", "[", "'startTime'", "]", ")", ")", "end", "=", "int", "(", "epoch", "(", "requestContext", "[", "'endTime'", "]", ")", ")", "if", "ts", "<", "start", ":", "raise", "ValueError", "(", "\"verticalLine(): timestamp %s exists \"", "\"before start of range\"", "%", "ts", ")", "elif", "ts", ">", "end", ":", "raise", "ValueError", "(", "\"verticalLine(): timestamp %s exists \"", "\"after end of range\"", "%", "ts", ")", "start", "=", "end", "=", "ts", "step", "=", "1.0", "series", "=", "TimeSeries", "(", "label", ",", "start", ",", "end", ",", "step", ",", "[", "1.0", ",", "1.0", "]", ")", "series", ".", "options", "[", "'drawAsInfinite'", "]", "=", "True", "if", "color", ":", "series", ".", "color", "=", "color", "return", "[", "series", "]" ]

[ "Takes", "a", "timestamp", "string", "ts", "." ]

[ "def", "threshold", "(", "requestContext", ",", "value", ",", "label", "=", "None", ",", "color", "=", "None", ")", ":", "[", "series", "]", "=", "constantLine", "(", "requestContext", ",", "value", ")", "if", "label", ":", "series", ".", "name", "=", "label", "if", "color", ":", "series", ".", "color", "=", "color", "return", "[", "series", "]" ]

[ "Takes", "a", "float", "F", "followed", "by", "a", "label", "(", "in", "double", "quotes", ")", "and", "a", "color", ".", "(", "See", "bgcolor", "in", "the", "render", "\\", "_api_", "for", "valid", "color", "names", "&", "formats", ".", ")" ]

[ "def", "transformNull", "(", "requestContext", ",", "seriesList", ",", "default", "=", "0", ",", "referenceSeries", "=", "None", ")", ":", "def", "transform", "(", "v", ",", "d", ")", ":", "if", "v", "is", "None", ":", "return", "d", "else", ":", "return", "v", "if", "referenceSeries", ":", "defaults", "=", "[", "default", "if", "any", "(", "v", "is", "not", "None", "for", "v", "in", "x", ")", "else", "None", "for", "x", "in", "zip_longest", "(", "*", "referenceSeries", ")", "]", "else", ":", "defaults", "=", "None", "for", "series", "in", "seriesList", ":", "if", "referenceSeries", ":", "series", ".", "name", "=", "\"transformNull(%s,%g,referenceSeries)\"", "%", "(", "series", ".", "name", ",", "default", ")", "else", ":", "series", ".", "name", "=", "\"transformNull(%s,%g)\"", "%", "(", "series", ".", "name", ",", "default", ")", "series", ".", "pathExpression", "=", "series", ".", "name", "if", "defaults", ":", "values", "=", "[", "transform", "(", "v", ",", "d", ")", "for", "v", ",", "d", "in", "zip_longest", "(", "series", ",", "defaults", ")", "]", "else", ":", "values", "=", "[", "transform", "(", "v", ",", "default", ")", "for", "v", "in", "series", "]", "series", ".", "extend", "(", "values", ")", "del", "series", "[", ":", "len", "(", "values", ")", "]", "return", "seriesList" ]

[ "Takes", "a", "metric", "or", "wildcard", "seriesList", "and", "replaces", "null", "values", "with", "the", "value", "specified", "by", "default", ".", "The", "value", "0", "used", "if", "not", "specified", ".", "The", "optional", "referenceSeries", "if", "specified", "is", "a", "metric", "or", "wildcard", "series", "list", "that", "governs", "which", "time", "intervals", "nulls", "should", "be", "replaced", ".", "If", "specified", "nulls", "are", "replaced", "only", "in", "intervals", "where", "a", "non", "-", "null", "is", "found", "for", "the", "same", "interval", "in", "any", "of", "referenceSeries", ".", "This", "method", "compliments", "the", "drawNullAsZero", "function", "in", "graphical", "mode", "but", "also", "works", "in", "text", "-", "only", "mode", "." ]

[ "def", "isNonNull", "(", "requestContext", ",", "seriesList", ")", ":", "def", "transform", "(", "v", ")", ":", "if", "v", "is", "None", ":", "return", "0", "else", ":", "return", "1", "for", "series", "in", "seriesList", ":", "series", ".", "name", "=", "\"isNonNull(%s)\"", "%", "(", "series", ".", "name", ")", "series", ".", "pathExpression", "=", "series", ".", "name", "values", "=", "[", "transform", "(", "v", ")", "for", "v", "in", "series", "]", "series", ".", "extend", "(", "values", ")", "del", "series", "[", ":", "len", "(", "values", ")", "]", "return", "seriesList" ]

[ "Takes", "a", "metric", "or", "wild", "card", "seriesList", "and", "counts", "up", "how", "many", "non", "-", "null", "values", "are", "specified", ".", "This", "is", "useful", "for", "understanding", "which", "metrics", "have", "data", "at", "a", "given", "point", "in", "time", "(", "ie", "to", "count", "which", "servers", "are", "alive", ")", "." ]

[ "def", "identity", "(", "requestContext", ",", "name", ",", "step", "=", "60", ")", ":", "start", "=", "int", "(", "epoch", "(", "requestContext", "[", "\"startTime\"", "]", ")", ")", "end", "=", "int", "(", "epoch", "(", "requestContext", "[", "\"endTime\"", "]", ")", ")", "values", "=", "range", "(", "start", ",", "end", ",", "step", ")", "series", "=", "TimeSeries", "(", "name", ",", "start", ",", "end", ",", "step", ",", "values", ")", "series", ".", "pathExpression", "=", "'identity(\"%s\")'", "%", "name", "return", "[", "series", "]" ]

[ "Identity", "function", ":", "Returns", "datapoints", "where", "the", "value", "equals", "the", "timestamp", "of", "the", "datapoint", ".", "Useful", "when", "you", "have", "another", "series", "where", "the", "value", "is", "a", "timestamp", "and", "you", "want", "to", "compare", "it", "to", "the", "time", "of", "the", "datapoint", "to", "render", "an", "age" ]

[ "def", "countSeries", "(", "requestContext", ",", "*", "seriesLists", ")", ":", "if", "not", "seriesLists", "or", "not", "any", "(", "seriesLists", ")", ":", "series", "=", "constantLine", "(", "requestContext", ",", "0", ")", ".", "pop", "(", ")", "series", ".", "pathExpression", "=", "\"countSeries()\"", "else", ":", "seriesList", ",", "start", ",", "end", ",", "step", "=", "normalize", "(", "seriesLists", ")", "name", "=", "\"countSeries(%s)\"", "%", "formatPathExpressions", "(", "seriesList", ")", "values", "=", "(", "int", "(", "len", "(", "row", ")", ")", "for", "row", "in", "zip_longest", "(", "*", "seriesList", ")", ")", "series", "=", "TimeSeries", "(", "name", ",", "start", ",", "end", ",", "step", ",", "values", ")", "series", ".", "pathExpression", "=", "name", "return", "[", "series", "]" ]

[ "Draws", "a", "horizontal", "line", "representing", "the", "number", "of", "nodes", "found", "in", "the", "seriesList", "." ]

[ "def", "group", "(", "requestContext", ",", "*", "seriesLists", ")", ":", "seriesGroup", "=", "[", "]", "for", "s", "in", "seriesLists", ":", "seriesGroup", ".", "extend", "(", "s", ")", "return", "seriesGroup" ]

[ "Takes", "an", "arbitrary", "number", "of", "seriesLists", "and", "adds", "them", "to", "a", "single", "seriesList", ".", "This", "is", "used", "to", "pass", "multiple", "seriesLists", "to", "a", "function", "which", "only", "takes", "one", "." ]

[ "def", "mapSeries", "(", "requestContext", ",", "seriesList", ",", "mapNode", ")", ":", "metaSeries", "=", "{", "}", "keys", "=", "[", "]", "for", "series", "in", "seriesList", ":", "key", "=", "series", ".", "name", ".", "split", "(", "\".\"", ")", "[", "mapNode", "]", "if", "key", "not", "in", "metaSeries", ":", "metaSeries", "[", "key", "]", "=", "[", "series", "]", "keys", ".", "append", "(", "key", ")", "else", ":", "metaSeries", "[", "key", "]", ".", "append", "(", "series", ")", "return", "[", "metaSeries", "[", "k", "]", "for", "k", "in", "keys", "]" ]

[ "Short", "form", ":", "map", "()", "." ]

[ "def", "reduceSeries", "(", "requestContext", ",", "seriesLists", ",", "reduceFunction", ",", "reduceNode", ",", "*", "reduceMatchers", ")", ":", "metaSeries", "=", "{", "}", "keys", "=", "[", "]", "for", "seriesList", "in", "seriesLists", ":", "for", "series", "in", "seriesList", ":", "nodes", "=", "series", ".", "name", ".", "split", "(", "'.'", ")", "node", "=", "nodes", "[", "reduceNode", "]", "reduceSeriesName", "=", "'.'", ".", "join", "(", "nodes", "[", "0", ":", "reduceNode", "]", ")", "+", "'.reduce.'", "+", "reduceFunction", "if", "node", "in", "reduceMatchers", ":", "if", "reduceSeriesName", "not", "in", "metaSeries", ":", "metaSeries", "[", "reduceSeriesName", "]", "=", "[", "None", "]", "*", "len", "(", "reduceMatchers", ")", "keys", ".", "append", "(", "reduceSeriesName", ")", "i", "=", "reduceMatchers", ".", "index", "(", "node", ")", "metaSeries", "[", "reduceSeriesName", "]", "[", "i", "]", "=", "series", "for", "key", "in", "keys", ":", "metaSeries", "[", "key", "]", "=", "app", ".", "functions", "[", "reduceFunction", "]", "(", "requestContext", ",", "*", "[", "[", "s", "]", "for", "s", "in", "metaSeries", "[", "key", "]", "]", ")", "[", "0", "]", "metaSeries", "[", "key", "]", ".", "name", "=", "key", "return", "[", "metaSeries", "[", "key", "]", "for", "key", "in", "keys", "]" ]

[ "Short", "form", ":", "reduce", "()", "." ]

[ "def", "applyByNode", "(", "requestContext", ",", "seriesList", ",", "nodeNum", ",", "templateFunction", ",", "newName", "=", "None", ")", ":", "from", ".", "app", "import", "evaluateTarget", "prefixes", "=", "set", "(", ")", "for", "series", "in", "seriesList", ":", "prefix", "=", "'.'", ".", "join", "(", "series", ".", "name", ".", "split", "(", "'.'", ")", "[", ":", "nodeNum", "+", "1", "]", ")", "prefixes", ".", "add", "(", "prefix", ")", "results", "=", "[", "]", "for", "prefix", "in", "sorted", "(", "prefixes", ")", ":", "target", "=", "templateFunction", ".", "replace", "(", "'%'", ",", "prefix", ")", "for", "resultSeries", "in", "evaluateTarget", "(", "requestContext", ",", "target", ")", ":", "if", "newName", ":", "resultSeries", ".", "name", "=", "newName", ".", "replace", "(", "'%'", ",", "prefix", ")", "resultSeries", ".", "pathExpression", "=", "prefix", "resultSeries", ".", "start", "=", "series", ".", "start", "resultSeries", ".", "end", "=", "series", ".", "end", "results", ".", "append", "(", "resultSeries", ")", "return", "results" ]

[ "Takes", "a", "seriesList", "and", "applies", "some", "complicated", "function", "(", "described", "by", "a", "string", ")", "replacing", "templates", "with", "unique", "prefixes", "of", "keys", "from", "the", "seriesList", "(", "the", "key", "is", "all", "nodes", "up", "to", "the", "index", "given", "as", "nodeNum", ")", "." ]

[ "def", "groupByNode", "(", "requestContext", ",", "seriesList", ",", "nodeNum", ",", "callback", ")", ":", "return", "groupByNodes", "(", "requestContext", ",", "seriesList", ",", "callback", ",", "nodeNum", ")" ]

[ "Takes", "a", "serieslist", "and", "maps", "a", "callback", "to", "subgroups", "within", "as", "defined", "by", "a", "common", "node", "." ]

[ "def", "groupByNodes", "(", "requestContext", ",", "seriesList", ",", "callback", ",", "*", "nodes", ")", ":", "from", ".", "app", "import", "app", "metaSeries", "=", "{", "}", "keys", "=", "[", "]", "if", "isinstance", "(", "nodes", ",", "int", ")", ":", "nodes", "=", "[", "nodes", "]", "for", "series", "in", "seriesList", ":", "key", "=", "'.'", ".", "join", "(", "series", ".", "name", ".", "split", "(", "\".\"", ")", "[", "n", "]", "for", "n", "in", "nodes", ")", "if", "key", "not", "in", "metaSeries", ":", "metaSeries", "[", "key", "]", "=", "[", "series", "]", "keys", ".", "append", "(", "key", ")", "else", ":", "metaSeries", "[", "key", "]", ".", "append", "(", "series", ")", "for", "key", "in", "metaSeries", ":", "metaSeries", "[", "key", "]", "=", "app", ".", "functions", "[", "callback", "]", "(", "requestContext", ",", "metaSeries", "[", "key", "]", ")", "[", "0", "]", "metaSeries", "[", "key", "]", ".", "name", "=", "key", "return", "[", "metaSeries", "[", "key", "]", "for", "key", "in", "keys", "]" ]

[ "Takes", "a", "serieslist", "and", "maps", "a", "callback", "to", "subgroups", "within", "as", "defined", "by", "multiple", "nodes", "." ]

[ "def", "exclude", "(", "requestContext", ",", "seriesList", ",", "pattern", ")", ":", "regex", "=", "re", ".", "compile", "(", "pattern", ")", "return", "[", "s", "for", "s", "in", "seriesList", "if", "not", "regex", ".", "search", "(", "s", ".", "name", ")", "]" ]

[ "Takes", "a", "metric", "or", "a", "wildcard", "seriesList", "followed", "by", "a", "regular", "expression", "in", "double", "quotes", ".", "Excludes", "metrics", "that", "match", "the", "regular", "expression", "." ]

[ "def", "smartSummarize", "(", "requestContext", ",", "seriesList", ",", "intervalString", ",", "func", "=", "'sum'", ")", ":", "results", "=", "[", "]", "delta", "=", "parseTimeOffset", "(", "intervalString", ")", "interval", "=", "to_seconds", "(", "delta", ")", "# Adjust the start time to fit an entire day for intervals >= 1 day", "requestContext", "=", "requestContext", ".", "copy", "(", ")", "tzinfo", "=", "requestContext", "[", "'tzinfo'", "]", "s", "=", "requestContext", "[", "'startTime'", "]", "if", "interval", ">=", "DAY", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "tzinfo", "=", "tzinfo", ")", "elif", "interval", ">=", "HOUR", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "s", ".", "hour", ",", "tzinfo", "=", "tzinfo", ")", "elif", "interval", ">=", "MINUTE", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "s", ".", "hour", ",", "s", ".", "minute", ",", "tzinfo", "=", "tzinfo", ")", "paths", "=", "[", "]", "for", "series", "in", "seriesList", ":", "paths", ".", "extend", "(", "pathsFromTarget", "(", "requestContext", ",", "series", ".", "pathExpression", ")", ")", "data_store", "=", "fetchData", "(", "requestContext", ",", "paths", ")", "for", "series", "in", "seriesList", ":", "# XXX: breaks with summarize(metric.{a,b})", "# each series.pathExpression == metric.{a,b}", "newSeries", "=", "evaluateTarget", "(", "requestContext", ",", "series", ".", "pathExpression", ",", "data_store", ")", "[", "0", "]", "series", "[", "0", ":", "len", "(", "series", ")", "]", "=", "newSeries", "series", ".", "start", "=", "newSeries", ".", "start", "series", ".", "end", "=", "newSeries", ".", "end", "series", ".", "step", "=", "newSeries", ".", "step", "for", "series", "in", "seriesList", ":", "buckets", "=", "{", "}", "# {timestamp: [values]}", "timestamps", "=", "range", "(", "int", "(", "series", ".", "start", ")", ",", "int", "(", "series", ".", "end", ")", ",", "int", "(", "series", ".", "step", ")", ")", "datapoints", "=", "zip_longest", "(", "timestamps", ",", "series", ")", "# Populate buckets", "for", "timestamp", ",", "value", "in", "datapoints", ":", "# ISSUE: Sometimes there is a missing timestamp in datapoints when", "# running a smartSummary", "if", "not", "timestamp", ":", "continue", "bucketInterval", "=", "int", "(", "(", "timestamp", "-", "series", ".", "start", ")", "/", "interval", ")", "if", "bucketInterval", "not", "in", "buckets", ":", "buckets", "[", "bucketInterval", "]", "=", "[", "]", "if", "value", "is", "not", "None", ":", "buckets", "[", "bucketInterval", "]", ".", "append", "(", "value", ")", "newValues", "=", "[", "]", "for", "timestamp", "in", "range", "(", "series", ".", "start", ",", "series", ".", "end", ",", "interval", ")", ":", "bucketInterval", "=", "int", "(", "(", "timestamp", "-", "series", ".", "start", ")", "/", "interval", ")", "bucket", "=", "buckets", ".", "get", "(", "bucketInterval", ",", "[", "]", ")", "if", "bucket", ":", "if", "func", "==", "'avg'", ":", "newValues", ".", "append", "(", "float", "(", "sum", "(", "bucket", ")", ")", "/", "float", "(", "len", "(", "bucket", ")", ")", ")", "elif", "func", "==", "'last'", ":", "newValues", ".", "append", "(", "bucket", "[", "len", "(", "bucket", ")", "-", "1", "]", ")", "elif", "func", "==", "'max'", ":", "newValues", ".", "append", "(", "max", "(", "bucket", ")", ")", "elif", "func", "==", "'min'", ":", "newValues", ".", "append", "(", "min", "(", "bucket", ")", ")", "else", ":", "newValues", ".", "append", "(", "sum", "(", "bucket", ")", ")", "else", ":", "newValues", ".", "append", "(", "None", ")", "newName", "=", "\"smartSummarize(%s, \\\"%s\\\", \\\"%s\\\")\"", "%", "(", "series", ".", "name", ",", "intervalString", ",", "func", ")", "alignedEnd", "=", "series", ".", "start", "+", "(", "bucketInterval", "*", "interval", ")", "+", "interval", "newSeries", "=", "TimeSeries", "(", "newName", ",", "series", ".", "start", ",", "alignedEnd", ",", "interval", ",", "newValues", ")", "newSeries", ".", "pathExpression", "=", "newName", "results", ".", "append", "(", "newSeries", ")", "return", "results" ]

[ "Smarter", "experimental", "version", "of", "summarize", "." ]

[ "def", "summarize", "(", "requestContext", ",", "seriesList", ",", "intervalString", ",", "func", "=", "'sum'", ",", "alignToFrom", "=", "False", ")", ":", "results", "=", "[", "]", "delta", "=", "parseTimeOffset", "(", "intervalString", ")", "interval", "=", "to_seconds", "(", "delta", ")", "for", "series", "in", "seriesList", ":", "buckets", "=", "{", "}", "timestamps", "=", "range", "(", "int", "(", "series", ".", "start", ")", ",", "int", "(", "series", ".", "end", ")", "+", "1", ",", "int", "(", "series", ".", "step", ")", ")", "datapoints", "=", "zip_longest", "(", "timestamps", ",", "series", ")", "for", "timestamp", ",", "value", "in", "datapoints", ":", "if", "timestamp", "is", "None", ":", "continue", "if", "alignToFrom", ":", "bucketInterval", "=", "int", "(", "(", "timestamp", "-", "series", ".", "start", ")", "/", "interval", ")", "else", ":", "bucketInterval", "=", "timestamp", "-", "(", "timestamp", "%", "interval", ")", "if", "bucketInterval", "not", "in", "buckets", ":", "buckets", "[", "bucketInterval", "]", "=", "[", "]", "if", "value", "is", "not", "None", ":", "buckets", "[", "bucketInterval", "]", ".", "append", "(", "value", ")", "if", "alignToFrom", ":", "newStart", "=", "series", ".", "start", "newEnd", "=", "series", ".", "end", "else", ":", "newStart", "=", "series", ".", "start", "-", "(", "series", ".", "start", "%", "interval", ")", "newEnd", "=", "series", ".", "end", "-", "(", "series", ".", "end", "%", "interval", ")", "+", "interval", "newValues", "=", "[", "]", "for", "timestamp", "in", "range", "(", "newStart", ",", "newEnd", ",", "interval", ")", ":", "if", "alignToFrom", ":", "newEnd", "=", "timestamp", "bucketInterval", "=", "int", "(", "(", "timestamp", "-", "series", ".", "start", ")", "/", "interval", ")", "else", ":", "bucketInterval", "=", "timestamp", "-", "(", "timestamp", "%", "interval", ")", "bucket", "=", "buckets", ".", "get", "(", "bucketInterval", ",", "[", "]", ")", "if", "bucket", ":", "if", "func", "==", "'avg'", ":", "newValues", ".", "append", "(", "float", "(", "sum", "(", "bucket", ")", ")", "/", "float", "(", "len", "(", "bucket", ")", ")", ")", "elif", "func", "==", "'last'", ":", "newValues", ".", "append", "(", "bucket", "[", "len", "(", "bucket", ")", "-", "1", "]", ")", "elif", "func", "==", "'max'", ":", "newValues", ".", "append", "(", "max", "(", "bucket", ")", ")", "elif", "func", "==", "'min'", ":", "newValues", ".", "append", "(", "min", "(", "bucket", ")", ")", "else", ":", "newValues", ".", "append", "(", "sum", "(", "bucket", ")", ")", "else", ":", "newValues", ".", "append", "(", "None", ")", "if", "alignToFrom", ":", "newEnd", "+=", "interval", "newName", "=", "\"summarize(%s, \\\"%s\\\", \\\"%s\\\"%s)\"", "%", "(", "series", ".", "name", ",", "intervalString", ",", "func", ",", "alignToFrom", "and", "\", true\"", "or", "\"\"", ")", "newSeries", "=", "TimeSeries", "(", "newName", ",", "newStart", ",", "newEnd", ",", "interval", ",", "newValues", ")", "newSeries", ".", "pathExpression", "=", "newName", "results", ".", "append", "(", "newSeries", ")", "return", "results" ]

[ "Summarize", "the", "data", "into", "interval", "buckets", "of", "a", "certain", "size", "." ]

[ "def", "hitcount", "(", "requestContext", ",", "seriesList", ",", "intervalString", ",", "alignToInterval", "=", "False", ")", ":", "results", "=", "[", "]", "delta", "=", "parseTimeOffset", "(", "intervalString", ")", "interval", "=", "to_seconds", "(", "delta", ")", "if", "alignToInterval", ":", "requestContext", "=", "requestContext", ".", "copy", "(", ")", "tzinfo", "=", "requestContext", "[", "'tzinfo'", "]", "s", "=", "requestContext", "[", "'startTime'", "]", "if", "interval", ">=", "DAY", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "tzinfo", "=", "tzinfo", ")", "elif", "interval", ">=", "HOUR", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "s", ".", "hour", ",", "tzinfo", "=", "tzinfo", ")", "elif", "interval", ">=", "MINUTE", ":", "requestContext", "[", "'startTime'", "]", "=", "datetime", "(", "s", ".", "year", ",", "s", ".", "month", ",", "s", ".", "day", ",", "s", ".", "hour", ",", "s", ".", "minute", ",", "tzinfo", "=", "tzinfo", ")", "# Gather all paths first, then the data", "paths", "=", "[", "]", "for", "series", "in", "seriesList", ":", "paths", ".", "extend", "(", "pathsFromTarget", "(", "requestContext", ",", "series", ".", "pathExpression", ")", ")", "data_store", "=", "fetchData", "(", "requestContext", ",", "paths", ")", "for", "series", "in", "seriesList", ":", "newSeries", "=", "evaluateTarget", "(", "requestContext", ",", "series", ".", "pathExpression", ",", "data_store", ")", "[", "0", "]", "intervalCount", "=", "int", "(", "(", "series", ".", "end", "-", "series", ".", "start", ")", "/", "interval", ")", "series", "[", "0", ":", "len", "(", "series", ")", "]", "=", "newSeries", "series", ".", "start", "=", "newSeries", ".", "start", "series", ".", "end", "=", "newSeries", ".", "start", "+", "(", "intervalCount", "*", "interval", ")", "+", "interval", "series", ".", "step", "=", "newSeries", ".", "step", "for", "series", "in", "seriesList", ":", "step", "=", "int", "(", "series", ".", "step", ")", "bucket_count", "=", "int", "(", "math", ".", "ceil", "(", "float", "(", "series", ".", "end", "-", "series", ".", "start", ")", "/", "interval", ")", ")", "buckets", "=", "[", "[", "]", "for", "_", "in", "range", "(", "bucket_count", ")", "]", "newStart", "=", "int", "(", "series", ".", "end", "-", "bucket_count", "*", "interval", ")", "for", "i", ",", "value", "in", "enumerate", "(", "series", ")", ":", "if", "value", "is", "None", ":", "continue", "start_time", "=", "int", "(", "series", ".", "start", "+", "i", "*", "step", ")", "start_bucket", ",", "start_mod", "=", "divmod", "(", "start_time", "-", "newStart", ",", "interval", ")", "end_time", "=", "start_time", "+", "step", "end_bucket", ",", "end_mod", "=", "divmod", "(", "end_time", "-", "newStart", ",", "interval", ")", "if", "end_bucket", ">=", "bucket_count", ":", "end_bucket", "=", "bucket_count", "-", "1", "end_mod", "=", "interval", "if", "start_bucket", "==", "end_bucket", ":", "# All of the hits go to a single bucket.", "if", "start_bucket", ">=", "0", ":", "buckets", "[", "start_bucket", "]", ".", "append", "(", "value", "*", "(", "end_mod", "-", "start_mod", ")", ")", "else", ":", "# Spread the hits among 2 or more buckets.", "if", "start_bucket", ">=", "0", ":", "buckets", "[", "start_bucket", "]", ".", "append", "(", "value", "*", "(", "interval", "-", "start_mod", ")", ")", "hits_per_bucket", "=", "value", "*", "interval", "for", "j", "in", "range", "(", "start_bucket", "+", "1", ",", "end_bucket", ")", ":", "buckets", "[", "j", "]", ".", "append", "(", "hits_per_bucket", ")", "if", "end_mod", ">", "0", ":", "buckets", "[", "end_bucket", "]", ".", "append", "(", "value", "*", "end_mod", ")", "newValues", "=", "[", "]", "for", "bucket", "in", "buckets", ":", "if", "bucket", ":", "newValues", ".", "append", "(", "sum", "(", "bucket", ")", ")", "else", ":", "newValues", ".", "append", "(", "None", ")", "newName", "=", "'hitcount(%s, \"%s\"%s)'", "%", "(", "series", ".", "name", ",", "intervalString", ",", "alignToInterval", "and", "\", true\"", "or", "\"\"", ")", "newSeries", "=", "TimeSeries", "(", "newName", ",", "newStart", ",", "series", ".", "end", ",", "interval", ",", "newValues", ")", "newSeries", ".", "pathExpression", "=", "newName", "results", ".", "append", "(", "newSeries", ")", "return", "results" ]

[ "Estimate", "hit", "counts", "from", "a", "list", "of", "time", "series", "." ]

[ "def", "timeFunction", "(", "requestContext", ",", "name", ",", "step", "=", "60", ")", ":", "start", "=", "int", "(", "epoch", "(", "requestContext", "[", "\"startTime\"", "]", ")", ")", "end", "=", "int", "(", "epoch", "(", "requestContext", "[", "\"endTime\"", "]", ")", ")", "delta", "=", "timedelta", "(", "seconds", "=", "step", ")", "when", "=", "requestContext", "[", "\"startTime\"", "]", "values", "=", "[", "]", "while", "when", "<", "requestContext", "[", "\"endTime\"", "]", ":", "values", ".", "append", "(", "epoch", "(", "when", ")", ")", "when", "+=", "delta", "series", "=", "TimeSeries", "(", "name", ",", "start", ",", "end", ",", "step", ",", "values", ")", "series", ".", "pathExpression", "=", "name", "return", "[", "series", "]" ]

[ "Short", "Alias", ":", "time", "()" ]

[ "def", "sinFunction", "(", "requestContext", ",", "name", ",", "amplitude", "=", "1", ",", "step", "=", "60", ")", ":", "delta", "=", "timedelta", "(", "seconds", "=", "step", ")", "when", "=", "requestContext", "[", "\"startTime\"", "]", "values", "=", "[", "]", "while", "when", "<", "requestContext", "[", "\"endTime\"", "]", ":", "values", ".", "append", "(", "math", ".", "sin", "(", "epoch", "(", "when", ")", ")", "*", "amplitude", ")", "when", "+=", "delta", "series", "=", "TimeSeries", "(", "name", ",", "int", "(", "epoch", "(", "requestContext", "[", "\"startTime\"", "]", ")", ")", ",", "int", "(", "epoch", "(", "requestContext", "[", "\"endTime\"", "]", ")", ")", ",", "step", ",", "values", ")", "series", ".", "pathExpression", "=", "'sin({0})'", ".", "format", "(", "name", ")", "return", "[", "series", "]" ]

[ "Short", "Alias", ":", "sin", "()" ]

[ "def", "randomWalkFunction", "(", "requestContext", ",", "name", ",", "step", "=", "60", ")", ":", "delta", "=", "timedelta", "(", "seconds", "=", "step", ")", "when", "=", "requestContext", "[", "\"startTime\"", "]", "values", "=", "[", "]", "current", "=", "0", "while", "when", "<", "requestContext", "[", "\"endTime\"", "]", ":", "values", ".", "append", "(", "current", ")", "current", "+=", "random", ".", "random", "(", ")", "-", "0.5", "when", "+=", "delta", "return", "[", "TimeSeries", "(", "name", ",", "int", "(", "epoch", "(", "requestContext", "[", "\"startTime\"", "]", ")", ")", ",", "int", "(", "epoch", "(", "requestContext", "[", "\"endTime\"", "]", ")", ")", ",", "step", ",", "values", ")", "]" ]

[ "Short", "Alias", ":", "randomWalk", "()" ]

[ "def", "validate", "(", "self", ",", "model", ",", "checks", "=", "[", "]", ")", ":", "custom", "=", "[", "check_partial", "(", "reaction_id_check", ",", "frozenset", "(", "r", ".", "id", "for", "r", "in", "model", ".", "reactions", ")", ")", "]", "super", "(", "Medium", ",", "self", ")", ".", "validate", "(", "model", "=", "model", ",", "checks", "=", "checks", "+", "custom", ")" ]

[ "Use", "a", "defined", "schema", "to", "validate", "the", "medium", "table", "format", "." ]

[ "def", "apply", "(", "self", ",", "model", ")", ":", "model", ".", "medium", "=", "{", "row", ".", "exchange", ":", "row", ".", "uptake", "for", "row", "in", "self", ".", "data", ".", "itertuples", "(", "index", "=", "False", ")", "}" ]

[ "Set", "the", "defined", "medium", "on", "the", "given", "model", "." ]

[ "def", "add_environment_information", "(", "meta", ")", ":", "meta", "[", "\"timestamp\"", "]", "=", "datetime", ".", "utcnow", "(", ")", ".", "isoformat", "(", "\" \"", ")", "meta", "[", "\"platform\"", "]", "=", "platform", ".", "system", "(", ")", "meta", "[", "\"release\"", "]", "=", "platform", ".", "release", "(", ")", "meta", "[", "\"python\"", "]", "=", "platform", ".", "python_version", "(", ")", "meta", "[", "\"packages\"", "]", "=", "get_pkg_info", "(", "\"memote\"", ")" ]

[ "Record", "environment", "information", "." ]

[ "def", "find_transported_elements", "(", "rxn", ")", ":", "element_dist", "=", "defaultdict", "(", ")", "# Collecting elements for each metabolite.", "for", "met", "in", "rxn", ".", "metabolites", ":", "if", "met", ".", "compartment", "not", "in", "element_dist", ":", "# Multiplication by the metabolite stoichiometry.", "element_dist", "[", "met", ".", "compartment", "]", "=", "{", "k", ":", "v", "*", "rxn", ".", "metabolites", "[", "met", "]", "for", "(", "k", ",", "v", ")", "in", "iteritems", "(", "met", ".", "elements", ")", "}", "else", ":", "x", "=", "{", "k", ":", "v", "*", "rxn", ".", "metabolites", "[", "met", "]", "for", "(", "k", ",", "v", ")", "in", "iteritems", "(", "met", ".", "elements", ")", "}", "y", "=", "element_dist", "[", "met", ".", "compartment", "]", "element_dist", "[", "met", ".", "compartment", "]", "=", "{", "k", ":", "x", ".", "get", "(", "k", ",", "0", ")", "+", "y", ".", "get", "(", "k", ",", "0", ")", "for", "k", "in", "set", "(", "x", ")", "|", "set", "(", "y", ")", "}", "delta_dict", "=", "defaultdict", "(", ")", "# Simplification of the resulting dictionary of dictionaries.", "for", "elements", "in", "itervalues", "(", "element_dist", ")", ":", "delta_dict", ".", "update", "(", "elements", ")", "# Only non-zero values get included in the returned delta-dict.", "delta_dict", "=", "{", "k", ":", "abs", "(", "v", ")", "for", "(", "k", ",", "v", ")", "in", "iteritems", "(", "delta_dict", ")", "if", "v", "!=", "0", "}", "return", "delta_dict" ]

[ "Return", "a", "dictionary", "showing", "the", "amount", "of", "transported", "elements", "of", "a", "rxn", "." ]

[ "def", "find_transport_reactions", "(", "model", ")", ":", "transport_reactions", "=", "[", "]", "transport_rxn_candidates", "=", "set", "(", "model", ".", "reactions", ")", "-", "set", "(", "model", ".", "boundary", ")", "-", "set", "(", "find_biomass_reaction", "(", "model", ")", ")", "transport_rxn_candidates", "=", "set", "(", "[", "rxn", "for", "rxn", "in", "transport_rxn_candidates", "if", "len", "(", "rxn", ".", "compartments", ")", ">=", "2", "]", ")", "# Add all labeled transport reactions", "sbo_matches", "=", "set", "(", "[", "rxn", "for", "rxn", "in", "transport_rxn_candidates", "if", "rxn", ".", "annotation", "is", "not", "None", "and", "'sbo'", "in", "rxn", ".", "annotation", "and", "rxn", ".", "annotation", "[", "'sbo'", "]", "in", "TRANSPORT_RXN_SBO_TERMS", "]", ")", "if", "len", "(", "sbo_matches", ")", ">", "0", ":", "transport_reactions", "+=", "list", "(", "sbo_matches", ")", "# Find unlabeled transport reactions via formula or annotation checks", "for", "rxn", "in", "transport_rxn_candidates", ":", "# Check if metabolites have formula field", "rxn_mets", "=", "set", "(", "[", "met", ".", "formula", "for", "met", "in", "rxn", ".", "metabolites", "]", ")", "if", "(", "None", "not", "in", "rxn_mets", ")", "and", "(", "len", "(", "rxn_mets", ")", "!=", "0", ")", ":", "if", "is_transport_reaction_formulae", "(", "rxn", ")", ":", "transport_reactions", ".", "append", "(", "rxn", ")", "elif", "is_transport_reaction_annotations", "(", "rxn", ")", ":", "transport_reactions", ".", "append", "(", "rxn", ")", "return", "set", "(", "transport_reactions", ")" ]

[ "Return", "a", "list", "of", "all", "transport", "reactions", "." ]

[ "def", "is_transport_reaction_formulae", "(", "rxn", ")", ":", "# Collecting criteria to classify transporters by.", "rxn_reactants", "=", "set", "(", "[", "met", ".", "formula", "for", "met", "in", "rxn", ".", "reactants", "]", ")", "rxn_products", "=", "set", "(", "[", "met", ".", "formula", "for", "met", "in", "rxn", ".", "products", "]", ")", "# Looking for formulas that stay the same on both side of the reaction.", "transported_mets", "=", "[", "formula", "for", "formula", "in", "rxn_reactants", "if", "formula", "in", "rxn_products", "]", "# Collect information on the elemental differences between", "# compartments in the reaction.", "delta_dicts", "=", "find_transported_elements", "(", "rxn", ")", "non_zero_array", "=", "[", "v", "for", "(", "k", ",", "v", ")", "in", "iteritems", "(", "delta_dicts", ")", "if", "v", "!=", "0", "]", "# Excluding reactions such as oxidoreductases where no net", "# transport of Hydrogen is occurring, but rather just an exchange of", "# electrons or charges effecting a change in protonation.", "if", "set", "(", "transported_mets", ")", "!=", "set", "(", "'H'", ")", "and", "list", "(", "delta_dicts", ".", "keys", "(", ")", ")", "==", "[", "'H'", "]", ":", "pass", "# All other reactions for which the amount of transported elements is", "# not zero, which are not part of the model's exchange nor", "# biomass reactions, are defined as transport reactions.", "# This includes reactions where the transported metabolite reacts with", "# a carrier molecule.", "elif", "sum", "(", "non_zero_array", ")", ":", "return", "True" ]

[ "Return", "boolean", "if", "a", "reaction", "is", "a", "transport", "reaction", "(", "from", "formulae", ")", "." ]

[ "def", "is_transport_reaction_annotations", "(", "rxn", ")", ":", "reactants", "=", "set", "(", "[", "(", "k", ",", "tuple", "(", "v", ")", ")", "for", "met", "in", "rxn", ".", "reactants", "for", "k", ",", "v", "in", "iteritems", "(", "met", ".", "annotation", ")", "if", "met", ".", "id", "!=", "\"H\"", "and", "k", "is", "not", "None", "and", "k", "!=", "'sbo'", "and", "v", "is", "not", "None", "]", ")", "products", "=", "set", "(", "[", "(", "k", ",", "tuple", "(", "v", ")", ")", "for", "met", "in", "rxn", ".", "products", "for", "k", ",", "v", "in", "iteritems", "(", "met", ".", "annotation", ")", "if", "met", ".", "id", "!=", "\"H\"", "and", "k", "is", "not", "None", "and", "k", "!=", "'sbo'", "and", "v", "is", "not", "None", "]", ")", "# Find intersection between reactant annotations and", "# product annotations to find common metabolites between them,", "# satisfying the requirements for a transport reaction. Reactions such", "# as those involving oxidoreductases (where no net transport of", "# Hydrogen is occurring, but rather just an exchange of electrons or", "# charges effecting a change in protonation) are excluded.", "transported_mets", "=", "reactants", "&", "products", "if", "len", "(", "transported_mets", ")", ">", "0", ":", "return", "True" ]

[ "Return", "boolean", "if", "a", "reaction", "is", "a", "transport", "reaction", "(", "from", "annotations", ")", "." ]

[ "def", "find_converting_reactions", "(", "model", ",", "pair", ")", ":", "first", "=", "set", "(", "find_met_in_model", "(", "model", ",", "pair", "[", "0", "]", ")", ")", "second", "=", "set", "(", "find_met_in_model", "(", "model", ",", "pair", "[", "1", "]", ")", ")", "hits", "=", "list", "(", ")", "for", "rxn", "in", "model", ".", "reactions", ":", "# FIXME: Use `set.issubset` much more idiomatic.", "if", "len", "(", "first", "&", "set", "(", "rxn", ".", "reactants", ")", ")", ">", "0", "and", "len", "(", "second", "&", "set", "(", "rxn", ".", "products", ")", ")", ">", "0", ":", "hits", ".", "append", "(", "rxn", ")", "elif", "len", "(", "first", "&", "set", "(", "rxn", ".", "products", ")", ")", ">", "0", "and", "len", "(", "second", "&", "set", "(", "rxn", ".", "reactants", ")", ")", ">", "0", ":", "hits", ".", "append", "(", "rxn", ")", "return", "frozenset", "(", "hits", ")" ]

[ "Find", "all", "reactions", "which", "convert", "a", "given", "metabolite", "pair", "." ]

[ "def", "find_biomass_reaction", "(", "model", ")", ":", "sbo_matches", "=", "set", "(", "[", "rxn", "for", "rxn", "in", "model", ".", "reactions", "if", "rxn", ".", "annotation", "is", "not", "None", "and", "'sbo'", "in", "rxn", ".", "annotation", "and", "rxn", ".", "annotation", "[", "'sbo'", "]", "==", "'SBO:0000629'", "]", ")", "if", "len", "(", "sbo_matches", ")", ">", "0", ":", "return", "list", "(", "sbo_matches", ")", "buzzwords", "=", "[", "'biomass'", ",", "'growth'", ",", "'bof'", "]", "buzzword_matches", "=", "set", "(", "[", "rxn", "for", "rxn", "in", "model", ".", "reactions", "if", "any", "(", "string", "in", "rxn", ".", "id", ".", "lower", "(", ")", "for", "string", "in", "buzzwords", ")", "]", ")", "biomass_met", "=", "[", "]", "for", "met", "in", "model", ".", "metabolites", ":", "if", "'biomass'", "in", "met", ".", "id", ".", "lower", "(", ")", "or", "(", "met", ".", "name", "is", "not", "None", "and", "'biomass'", "in", "met", ".", "name", ".", "lower", "(", ")", ")", ":", "biomass_met", ".", "append", "(", "met", ")", "if", "biomass_met", "==", "1", ":", "biomass_met_matches", "=", "set", "(", "biomass_met", ".", "reactions", ")", "-", "set", "(", "model", ".", "boundary", ")", "else", ":", "biomass_met_matches", "=", "set", "(", ")", "return", "list", "(", "buzzword_matches", "|", "biomass_met_matches", ")" ]

[ "Return", "a", "list", "of", "the", "biomass", "reaction", "(", "s", ")", "of", "the", "model", "." ]

[ "def", "find_demand_reactions", "(", "model", ")", ":", "try", ":", "extracellular", "=", "find_compartment_id_in_model", "(", "model", ",", "'e'", ")", "except", "KeyError", ":", "extracellular", "=", "None", "return", "find_boundary_types", "(", "model", ",", "'demand'", ",", "extracellular", ")" ]

[ "u", "Return", "a", "list", "of", "demand", "reactions", "." ]

[ "def", "find_sink_reactions", "(", "model", ")", ":", "try", ":", "extracellular", "=", "find_compartment_id_in_model", "(", "model", ",", "'e'", ")", "except", "KeyError", ":", "extracellular", "=", "None", "return", "find_boundary_types", "(", "model", ",", "'sink'", ",", "extracellular", ")" ]

[ "u", "Return", "a", "list", "of", "sink", "reactions", "." ]

[ "def", "find_exchange_rxns", "(", "model", ")", ":", "try", ":", "extracellular", "=", "find_compartment_id_in_model", "(", "model", ",", "'e'", ")", "except", "KeyError", ":", "extracellular", "=", "None", "return", "find_boundary_types", "(", "model", ",", "'exchange'", ",", "extracellular", ")" ]

[ "u", "Return", "a", "list", "of", "exchange", "reactions", "." ]

[ "def", "find_interchange_biomass_reactions", "(", "model", ",", "biomass", "=", "None", ")", ":", "boundary", "=", "set", "(", "model", ".", "boundary", ")", "transporters", "=", "find_transport_reactions", "(", "model", ")", "if", "biomass", "is", "None", ":", "biomass", "=", "set", "(", "find_biomass_reaction", "(", "model", ")", ")", "return", "boundary", "|", "transporters", "|", "biomass" ]

[ "Return", "the", "set", "of", "all", "transport", "boundary", "and", "biomass", "reactions", "." ]

[ "def", "run_fba", "(", "model", ",", "rxn_id", ",", "direction", "=", "\"max\"", ",", "single_value", "=", "True", ")", ":", "model", ".", "objective", "=", "model", ".", "reactions", ".", "get_by_id", "(", "rxn_id", ")", "model", ".", "objective_direction", "=", "direction", "if", "single_value", ":", "try", ":", "return", "model", ".", "slim_optimize", "(", ")", "except", "Infeasible", ":", "return", "np", ".", "nan", "else", ":", "try", ":", "solution", "=", "model", ".", "optimize", "(", ")", "return", "solution", "except", "Infeasible", ":", "return", "np", ".", "nan" ]

[ "Return", "the", "solution", "of", "an", "FBA", "to", "a", "set", "objective", "function", "." ]

[ "def", "close_boundaries_sensibly", "(", "model", ")", ":", "for", "rxn", "in", "model", ".", "reactions", ":", "if", "rxn", ".", "reversibility", ":", "rxn", ".", "bounds", "=", "-", "1", ",", "1", "else", ":", "rxn", ".", "bounds", "=", "0", ",", "1", "for", "boundary", "in", "model", ".", "boundary", ":", "boundary", ".", "bounds", "=", "(", "0", ",", "0", ")" ]

[ "Return", "a", "cobra", "model", "with", "all", "boundaries", "closed", "and", "changed", "constraints", "." ]

[ "def", "metabolites_per_compartment", "(", "model", ",", "compartment_id", ")", ":", "return", "[", "met", "for", "met", "in", "model", ".", "metabolites", "if", "met", ".", "compartment", "==", "compartment_id", "]" ]

[ "Identify", "all", "metabolites", "that", "belong", "to", "a", "given", "compartment", "." ]

[ "def", "largest_compartment_id_met", "(", "model", ")", ":", "# Sort compartments by decreasing size and extract the largest two.", "candidate", ",", "second", "=", "sorted", "(", "(", "(", "c", ",", "len", "(", "metabolites_per_compartment", "(", "model", ",", "c", ")", ")", ")", "for", "c", "in", "model", ".", "compartments", ")", ",", "reverse", "=", "True", ",", "key", "=", "itemgetter", "(", "1", ")", ")", "[", ":", "2", "]", "# Compare the size of the compartments.", "if", "candidate", "[", "1", "]", "==", "second", "[", "1", "]", ":", "raise", "RuntimeError", "(", "\"There is a tie for the largest compartment. \"", "\"Compartment {} and {} have equal amounts of \"", "\"metabolites.\"", ".", "format", "(", "candidate", "[", "0", "]", ",", "second", "[", "0", "]", ")", ")", "else", ":", "return", "candidate", "[", "0", "]" ]

[ "Return", "the", "ID", "of", "the", "compartment", "with", "the", "most", "metabolites", "." ]

[ "def", "find_compartment_id_in_model", "(", "model", ",", "compartment_id", ")", ":", "if", "compartment_id", "not", "in", "COMPARTMENT_SHORTLIST", ".", "keys", "(", ")", ":", "raise", "KeyError", "(", "\"{} is not in the COMPARTMENT_SHORTLIST! Make sure \"", "\"you typed the ID correctly, if yes, update the \"", "\"shortlist manually.\"", ".", "format", "(", "compartment_id", ")", ")", "if", "len", "(", "model", ".", "compartments", ")", "==", "0", ":", "raise", "KeyError", "(", "\"It was not possible to identify the \"", "\"compartment {}, since the \"", "\"model has no compartments at \"", "\"all.\"", ".", "format", "(", "COMPARTMENT_SHORTLIST", "[", "compartment_id", "]", "[", "0", "]", ")", ")", "if", "compartment_id", "in", "model", ".", "compartments", ".", "keys", "(", ")", ":", "return", "compartment_id", "for", "name", "in", "COMPARTMENT_SHORTLIST", "[", "compartment_id", "]", ":", "for", "c_id", ",", "c_name", "in", "model", ".", "compartments", ".", "items", "(", ")", ":", "if", "c_name", ".", "lower", "(", ")", "==", "name", ":", "return", "c_id", "if", "compartment_id", "==", "'c'", ":", "return", "largest_compartment_id_met", "(", "model", ")" ]

[ "Identify", "a", "model", "compartment", "by", "looking", "up", "names", "in", "COMPARTMENT_SHORTLIST", "." ]

[ "def", "find_met_in_model", "(", "model", ",", "mnx_id", ",", "compartment_id", "=", "None", ")", ":", "def", "compare_annotation", "(", "annotation", ")", ":", "\"\"\"\n Return annotation IDs that match to METANETX_SHORTLIST references.\n\n Compares the set of METANETX_SHORTLIST references for a given mnx_id\n and the annotation IDs stored in a given annotation dictionary.\n \"\"\"", "query_values", "=", "set", "(", "utils", ".", "flatten", "(", "annotation", ".", "values", "(", ")", ")", ")", "ref_values", "=", "set", "(", "utils", ".", "flatten", "(", "METANETX_SHORTLIST", "[", "mnx_id", "]", ")", ")", "return", "query_values", "&", "ref_values", "# Make sure that the MNX ID we're looking up exists in the metabolite", "# shortlist.", "if", "mnx_id", "not", "in", "METANETX_SHORTLIST", ".", "columns", ":", "raise", "ValueError", "(", "\"{} is not in the MetaNetX Shortlist! Make sure \"", "\"you typed the ID correctly, if yes, update the \"", "\"shortlist by updating and re-running the script \"", "\"generate_mnx_shortlists.py.\"", ".", "format", "(", "mnx_id", ")", ")", "candidates", "=", "[", "]", "# The MNX ID used in the model may or may not be tagged with a compartment", "# tag e.g. `MNXM23141_c` vs. `MNXM23141`, which is tested with the", "# following regex.", "# If the MNX ID itself cannot be found as an ID, we try all other", "# identifiers that are provided by our shortlist of MetaNetX' mapping", "# table.", "regex", "=", "re", ".", "compile", "(", "'^{}(_[a-zA-Z0-9]+)?$'", ".", "format", "(", "mnx_id", ")", ")", "if", "model", ".", "metabolites", ".", "query", "(", "regex", ")", ":", "candidates", "=", "model", ".", "metabolites", ".", "query", "(", "regex", ")", "elif", "model", ".", "metabolites", ".", "query", "(", "compare_annotation", ",", "attribute", "=", "'annotation'", ")", ":", "candidates", "=", "model", ".", "metabolites", ".", "query", "(", "compare_annotation", ",", "attribute", "=", "'annotation'", ")", "else", ":", "for", "value", "in", "METANETX_SHORTLIST", "[", "mnx_id", "]", ":", "if", "value", ":", "for", "ident", "in", "value", ":", "regex", "=", "re", ".", "compile", "(", "'^{}(_[a-zA-Z0-9]+)?$'", ".", "format", "(", "ident", ")", ")", "if", "model", ".", "metabolites", ".", "query", "(", "regex", ",", "attribute", "=", "'id'", ")", ":", "candidates", ".", "extend", "(", "model", ".", "metabolites", ".", "query", "(", "regex", ",", "attribute", "=", "'id'", ")", ")", "# Return a list of all possible candidates if no specific compartment ID", "# is provided.", "# Otherwise, just return the candidate in one specific compartment. Raise", "# an exception if there are more than one possible candidates for a given", "# compartment.", "if", "compartment_id", "is", "None", ":", "print", "(", "\"compartment_id = None?\"", ")", "return", "candidates", "else", ":", "candidates_in_compartment", "=", "[", "cand", "for", "cand", "in", "candidates", "if", "cand", ".", "compartment", "==", "compartment_id", "]", "if", "len", "(", "candidates_in_compartment", ")", "==", "0", ":", "raise", "RuntimeError", "(", "\"It was not possible to identify \"", "\"any metabolite in compartment {} corresponding to \"", "\"the following MetaNetX identifier: {}.\"", "\"Make sure that a cross-reference to this ID in \"", "\"the MetaNetX Database exists for your \"", "\"identifier \"", "\"namespace.\"", ".", "format", "(", "compartment_id", ",", "mnx_id", ")", ")", "elif", "len", "(", "candidates_in_compartment", ")", ">", "1", ":", "raise", "RuntimeError", "(", "\"It was not possible to uniquely identify \"", "\"a single metabolite in compartment {} that \"", "\"corresponds to the following MetaNetX \"", "\"identifier: {}.\"", "\"Instead these candidates were found: {}.\"", "\"Check that metabolite compartment tags are \"", "\"correct. Consider switching to a namespace scheme \"", "\"where identifiers are truly \"", "\"unique.\"", ".", "format", "(", "compartment_id", ",", "mnx_id", ",", "utils", ".", "get_ids", "(", "candidates_in_compartment", ")", ")", ")", "else", ":", "return", "candidates_in_compartment" ]

[ "Return", "specific", "metabolites", "by", "looking", "up", "IDs", "in", "METANETX_SHORTLIST", "." ]

[ "def", "find_bounds", "(", "model", ")", ":", "lower_bounds", "=", "np", ".", "asarray", "(", "[", "rxn", ".", "lower_bound", "for", "rxn", "in", "model", ".", "reactions", "]", ",", "dtype", "=", "float", ")", "upper_bounds", "=", "np", ".", "asarray", "(", "[", "rxn", ".", "upper_bound", "for", "rxn", "in", "model", ".", "reactions", "]", ",", "dtype", "=", "float", ")", "lower_bound", "=", "np", ".", "nanmedian", "(", "lower_bounds", "[", "lower_bounds", "!=", "0.0", "]", ")", "upper_bound", "=", "np", ".", "nanmedian", "(", "upper_bounds", "[", "upper_bounds", "!=", "0.0", "]", ")", "if", "np", ".", "isnan", "(", "lower_bound", ")", ":", "LOGGER", ".", "warning", "(", "\"Could not identify a median lower bound.\"", ")", "lower_bound", "=", "-", "1000.0", "if", "np", ".", "isnan", "(", "upper_bound", ")", ":", "LOGGER", ".", "warning", "(", "\"Could not identify a median upper bound.\"", ")", "upper_bound", "=", "1000.0", "return", "lower_bound", ",", "upper_bound" ]

[ "Return", "the", "median", "upper", "and", "lower", "bound", "of", "the", "metabolic", "model", "." ]

[ "def", "render_html", "(", "self", ")", ":", "return", "self", ".", "_template", ".", "safe_substitute", "(", "report_type", "=", "self", ".", "_report_type", ",", "results", "=", "self", ".", "render_json", "(", ")", ")" ]

[ "Render", "an", "HTML", "report", "." ]

[ "def", "compute_score", "(", "self", ")", ":", "# LOGGER.info(\"Begin scoring\")", "cases", "=", "self", ".", "get_configured_tests", "(", ")", "|", "set", "(", "self", ".", "result", ".", "cases", ")", "scores", "=", "DataFrame", "(", "{", "\"score\"", ":", "0.0", ",", "\"max\"", ":", "1.0", "}", ",", "index", "=", "sorted", "(", "cases", ")", ")", "self", ".", "result", ".", "setdefault", "(", "\"score\"", ",", "dict", "(", ")", ")", "self", ".", "result", "[", "\"score\"", "]", "[", "\"sections\"", "]", "=", "list", "(", ")", "# Calculate the scores for each test individually.", "for", "test", ",", "result", "in", "iteritems", "(", "self", ".", "result", ".", "cases", ")", ":", "# LOGGER.info(\"Calculate score for test: '%s'.\", test)", "# Test metric may be a dictionary for a parametrized test.", "metric", "=", "result", "[", "\"metric\"", "]", "if", "hasattr", "(", "metric", ",", "\"items\"", ")", ":", "result", "[", "\"score\"", "]", "=", "test_score", "=", "dict", "(", ")", "total", "=", "0.0", "for", "key", ",", "value", "in", "iteritems", "(", "metric", ")", ":", "value", "=", "1.0", "-", "value", "total", "+=", "value", "test_score", "[", "key", "]", "=", "value", "# For some reason there are parametrized tests without cases.", "if", "len", "(", "metric", ")", "==", "0", ":", "metric", "=", "0.0", "else", ":", "metric", "=", "total", "/", "len", "(", "metric", ")", "else", ":", "metric", "=", "1.0", "-", "metric", "scores", ".", "at", "[", "test", ",", "\"score\"", "]", "=", "metric", "scores", ".", "loc", "[", "test", ",", ":", "]", "*=", "self", ".", "config", "[", "\"weights\"", "]", ".", "get", "(", "test", ",", "1.0", ")", "score", "=", "0.0", "maximum", "=", "0.0", "# Calculate the scores for each section considering the individual test", "# case scores.", "for", "section_id", ",", "card", "in", "iteritems", "(", "self", ".", "config", "[", "'cards'", "]", "[", "'scored'", "]", "[", "'sections'", "]", ")", ":", "# LOGGER.info(\"Calculate score for section: '%s'.\", section_id)", "cases", "=", "card", ".", "get", "(", "\"cases\"", ",", "None", ")", "if", "cases", "is", "None", ":", "continue", "card_score", "=", "scores", ".", "loc", "[", "cases", ",", "\"score\"", "]", ".", "sum", "(", ")", "card_total", "=", "scores", ".", "loc", "[", "cases", ",", "\"max\"", "]", ".", "sum", "(", ")", "# Format results nicely to work immediately with Vega Bar Chart.", "section_score", "=", "{", "\"section\"", ":", "section_id", ",", "\"score\"", ":", "card_score", "/", "card_total", "}", "self", ".", "result", "[", "\"score\"", "]", "[", "\"sections\"", "]", ".", "append", "(", "section_score", ")", "# Calculate the final score for the entire model.", "weight", "=", "card", ".", "get", "(", "\"weight\"", ",", "1.0", ")", "score", "+=", "card_score", "*", "weight", "maximum", "+=", "card_total", "*", "weight", "self", ".", "result", "[", "\"score\"", "]", "[", "\"total_score\"", "]", "=", "score", "/", "maximum" ]

[ "Calculate", "the", "overall", "test", "score", "using", "the", "configuration", "." ]

[ "def", "find_components_without_sbo_terms", "(", "model", ",", "components", ")", ":", "return", "[", "elem", "for", "elem", "in", "getattr", "(", "model", ",", "components", ")", "if", "elem", ".", "annotation", "is", "None", "or", "'sbo'", "not", "in", "elem", ".", "annotation", "]" ]

[ "Find", "model", "components", "that", "are", "not", "annotated", "with", "any", "SBO", "terms", "." ]

[ "def", "check_component_for_specific_sbo_term", "(", "items", ",", "term", ")", ":", "# check for multiple allowable SBO terms", "if", "isinstance", "(", "term", ",", "list", ")", ":", "return", "[", "elem", "for", "elem", "in", "items", "if", "elem", ".", "annotation", "is", "None", "or", "'sbo'", "not", "in", "elem", ".", "annotation", "or", "not", "any", "(", "i", "in", "elem", ".", "annotation", "[", "'sbo'", "]", "for", "i", "in", "term", ")", "]", "else", ":", "return", "[", "elem", "for", "elem", "in", "items", "if", "elem", ".", "annotation", "is", "None", "or", "'sbo'", "not", "in", "elem", ".", "annotation", "or", "term", "not", "in", "elem", ".", "annotation", "[", "'sbo'", "]", "]" ]

[ "r", "Identify", "model", "components", "that", "lack", "a", "specific", "SBO", "term", "(", "s", ")", "." ]

[ "def", "get_smallest_compound_id", "(", "compounds_identifiers", ")", ":", "return", "min", "(", "(", "c", "for", "c", "in", "compounds_identifiers", "if", "c", ".", "startswith", "(", "\"C\"", ")", ")", ",", "key", "=", "lambda", "c", ":", "int", "(", "c", "[", "1", ":", "]", ")", ")" ]

[ "Return", "the", "smallest", "KEGG", "compound", "identifier", "from", "a", "list", "." ]

[ "def", "map_metabolite2kegg", "(", "metabolite", ")", ":", "logger", ".", "debug", "(", "\"Looking for KEGG compound identifier for %s.\"", ",", "metabolite", ".", "id", ")", "kegg_annotation", "=", "metabolite", ".", "annotation", ".", "get", "(", "\"kegg.compound\"", ")", "if", "kegg_annotation", "is", "None", ":", "# TODO (Moritz Beber): Currently name matching is very slow and", "# inaccurate. We disable it until there is a better solution.", "# if metabolite.name:", "# # The compound matcher uses regular expression and chokes", "# # with a low level error on `[` in the name, for example.", "# df = compound_matcher.match(metabolite.name)", "# try:", "# return df.loc[df[\"score\"] > threshold, \"CID\"].iat[0]", "# except (IndexError, AttributeError):", "# logger.warning(", "# \"Could not match the name %r to any kegg.compound \"", "# \"annotation for metabolite %s.\",", "# metabolite.name, metabolite.id", "# )", "# return", "# else:", "logger", ".", "warning", "(", "\"No kegg.compound annotation for metabolite %s.\"", ",", "metabolite", ".", "id", ")", "return", "if", "isinstance", "(", "kegg_annotation", ",", "string_types", ")", "and", "kegg_annotation", ".", "startswith", "(", "\"C\"", ")", ":", "return", "kegg_annotation", "elif", "isinstance", "(", "kegg_annotation", ",", "Iterable", ")", ":", "try", ":", "return", "get_smallest_compound_id", "(", "kegg_annotation", ")", "except", "ValueError", ":", "return", "logger", ".", "warning", "(", "\"No matching kegg.compound annotation for metabolite %s.\"", ",", "metabolite", ".", "id", ")", "return" ]

[ "Return", "a", "KEGG", "compound", "identifier", "for", "the", "metabolite", "if", "it", "exists", "." ]

[ "def", "translate_reaction", "(", "reaction", ",", "metabolite_mapping", ")", ":", "# Transport reactions where the same metabolite occurs in different", "# compartments should have been filtered out but just to be sure, we add", "# coefficients in the mapping.", "stoichiometry", "=", "defaultdict", "(", "float", ")", "for", "met", ",", "coef", "in", "iteritems", "(", "reaction", ".", "metabolites", ")", ":", "kegg_id", "=", "metabolite_mapping", ".", "setdefault", "(", "met", ",", "map_metabolite2kegg", "(", "met", ")", ")", "if", "kegg_id", "is", "None", ":", "continue", "stoichiometry", "[", "kegg_id", "]", "+=", "coef", "return", "dict", "(", "stoichiometry", ")" ]

[ "Return", "a", "mapping", "from", "KEGG", "compound", "identifiers", "to", "coefficients", "." ]

[ "def", "find_thermodynamic_reversibility_index", "(", "reactions", ")", ":", "incomplete_mapping", "=", "[", "]", "problematic_calculation", "=", "[", "]", "reversibility_indexes", "=", "[", "]", "unbalanced", "=", "[", "]", "metabolite_mapping", "=", "{", "}", "for", "rxn", "in", "reactions", ":", "stoich", "=", "translate_reaction", "(", "rxn", ",", "metabolite_mapping", ")", "if", "len", "(", "stoich", ")", "<", "len", "(", "rxn", ".", "metabolites", ")", ":", "incomplete_mapping", ".", "append", "(", "rxn", ")", "continue", "try", ":", "# Remove protons from stoichiometry.", "if", "\"C00080\"", "in", "stoich", ":", "del", "stoich", "[", "\"C00080\"", "]", "eq_rxn", "=", "Reaction", "(", "stoich", ",", "rxn", ".", "id", ")", "except", "KeyError", ":", "incomplete_mapping", ".", "append", "(", "rxn", ")", "continue", "if", "eq_rxn", ".", "check_full_reaction_balancing", "(", ")", ":", "try", ":", "ln_rev_index", "=", "eq_rxn", ".", "reversibility_index", "(", ")", "# TODO (Moritz Beber): Which exceptions can we expect here?", "except", "Exception", ":", "problematic_calculation", ".", "append", "(", "rxn", ")", "continue", "reversibility_indexes", ".", "append", "(", "(", "rxn", ",", "ln_rev_index", ")", ")", "else", ":", "unbalanced", ".", "append", "(", "rxn", ")", "reversibility_indexes", ".", "sort", "(", "key", "=", "lambda", "p", ":", "abs", "(", "p", "[", "1", "]", ")", ",", "reverse", "=", "True", ")", "return", "(", "reversibility_indexes", ",", "incomplete_mapping", ",", "problematic_calculation", ",", "unbalanced", ")" ]

[ "u", "Return", "the", "reversibility", "index", "of", "the", "given", "reactions", "." ]

[ "def", "check_stoichiometric_consistency", "(", "model", ")", ":", "problem", "=", "model", ".", "problem", "# The transpose of the stoichiometric matrix N.T in the paper.", "stoich_trans", "=", "problem", ".", "Model", "(", ")", "internal_rxns", "=", "con_helpers", ".", "get_internals", "(", "model", ")", "metabolites", "=", "set", "(", "met", "for", "rxn", "in", "internal_rxns", "for", "met", "in", "rxn", ".", "metabolites", ")", "LOGGER", ".", "info", "(", "\"model '%s' has %d internal reactions\"", ",", "model", ".", "id", ",", "len", "(", "internal_rxns", ")", ")", "LOGGER", ".", "info", "(", "\"model '%s' has %d internal metabolites\"", ",", "model", ".", "id", ",", "len", "(", "metabolites", ")", ")", "stoich_trans", ".", "add", "(", "[", "problem", ".", "Variable", "(", "m", ".", "id", ",", "lb", "=", "1", ")", "for", "m", "in", "metabolites", "]", ")", "stoich_trans", ".", "update", "(", ")", "con_helpers", ".", "add_reaction_constraints", "(", "stoich_trans", ",", "internal_rxns", ",", "problem", ".", "Constraint", ")", "# The objective is to minimize the metabolite mass vector.", "stoich_trans", ".", "objective", "=", "problem", ".", "Objective", "(", "Zero", ",", "direction", "=", "\"min\"", ",", "sloppy", "=", "True", ")", "stoich_trans", ".", "objective", ".", "set_linear_coefficients", "(", "{", "var", ":", "1.", "for", "var", "in", "stoich_trans", ".", "variables", "}", ")", "status", "=", "stoich_trans", ".", "optimize", "(", ")", "if", "status", "==", "OPTIMAL", ":", "return", "True", "elif", "status", "==", "INFEASIBLE", ":", "return", "False", "else", ":", "raise", "RuntimeError", "(", "\"Could not determine stoichiometric consistencty.\"", "\" Solver status is '{}'\"", "\" (only optimal or infeasible expected).\"", ".", "format", "(", "status", ")", ")" ]

[ "Verify", "the", "consistency", "of", "the", "model", "s", "stoichiometry", "." ]

[ "def", "find_unconserved_metabolites", "(", "model", ")", ":", "problem", "=", "model", ".", "problem", "stoich_trans", "=", "problem", ".", "Model", "(", ")", "internal_rxns", "=", "con_helpers", ".", "get_internals", "(", "model", ")", "metabolites", "=", "set", "(", "met", "for", "rxn", "in", "internal_rxns", "for", "met", "in", "rxn", ".", "metabolites", ")", "# The binary variables k[i] in the paper.", "k_vars", "=", "list", "(", ")", "for", "met", "in", "metabolites", ":", "# The element m[i] of the mass vector.", "m_var", "=", "problem", ".", "Variable", "(", "met", ".", "id", ")", "k_var", "=", "problem", ".", "Variable", "(", "\"k_{}\"", ".", "format", "(", "met", ".", "id", ")", ",", "type", "=", "\"binary\"", ")", "k_vars", ".", "append", "(", "k_var", ")", "stoich_trans", ".", "add", "(", "[", "m_var", ",", "k_var", "]", ")", "# This constraint is equivalent to 0 <= k[i] <= m[i].", "stoich_trans", ".", "add", "(", "problem", ".", "Constraint", "(", "k_var", "-", "m_var", ",", "ub", "=", "0", ",", "name", "=", "\"switch_{}\"", ".", "format", "(", "met", ".", "id", ")", ")", ")", "stoich_trans", ".", "update", "(", ")", "con_helpers", ".", "add_reaction_constraints", "(", "stoich_trans", ",", "internal_rxns", ",", "problem", ".", "Constraint", ")", "# The objective is to maximize the binary indicators k[i], subject to the", "# above inequality constraints.", "stoich_trans", ".", "objective", "=", "problem", ".", "Objective", "(", "Zero", ",", "sloppy", "=", "True", ",", "direction", "=", "\"max\"", ")", "stoich_trans", ".", "objective", ".", "set_linear_coefficients", "(", "{", "var", ":", "1.", "for", "var", "in", "k_vars", "}", ")", "status", "=", "stoich_trans", ".", "optimize", "(", ")", "if", "status", "==", "OPTIMAL", ":", "# TODO: See if that could be a Boolean test `bool(var.primal)`.", "return", "set", "(", "[", "model", ".", "metabolites", ".", "get_by_id", "(", "var", ".", "name", "[", "2", ":", "]", ")", "for", "var", "in", "k_vars", "if", "var", ".", "primal", "<", "0.8", "]", ")", "else", ":", "raise", "RuntimeError", "(", "\"Could not compute list of unconserved metabolites.\"", "\" Solver status is '{}' (only optimal expected).\"", ".", "format", "(", "status", ")", ")" ]

[ "Detect", "unconserved", "metabolites", "." ]

[ "def", "find_inconsistent_min_stoichiometry", "(", "model", ",", "atol", "=", "1e-13", ")", ":", "if", "check_stoichiometric_consistency", "(", "model", ")", ":", "return", "set", "(", ")", "Model", ",", "Constraint", ",", "Variable", ",", "Objective", "=", "con_helpers", ".", "get_interface", "(", "model", ")", "unconserved_mets", "=", "find_unconserved_metabolites", "(", "model", ")", "LOGGER", ".", "info", "(", "\"model has %d unconserved metabolites\"", ",", "len", "(", "unconserved_mets", ")", ")", "internal_rxns", "=", "con_helpers", ".", "get_internals", "(", "model", ")", "internal_mets", "=", "set", "(", "met", "for", "rxn", "in", "internal_rxns", "for", "met", "in", "rxn", ".", "metabolites", ")", "get_id", "=", "attrgetter", "(", "\"id\"", ")", "reactions", "=", "sorted", "(", "internal_rxns", ",", "key", "=", "get_id", ")", "metabolites", "=", "sorted", "(", "internal_mets", ",", "key", "=", "get_id", ")", "stoich", ",", "met_index", ",", "rxn_index", "=", "con_helpers", ".", "stoichiometry_matrix", "(", "metabolites", ",", "reactions", ")", "left_ns", "=", "con_helpers", ".", "nullspace", "(", "stoich", ".", "T", ")", "# deal with numerical instabilities", "left_ns", "[", "np", ".", "abs", "(", "left_ns", ")", "<", "atol", "]", "=", "0.0", "LOGGER", ".", "info", "(", "\"nullspace has dimension %d\"", ",", "left_ns", ".", "shape", "[", "1", "]", ")", "inc_minimal", "=", "set", "(", ")", "(", "problem", ",", "indicators", ")", "=", "con_helpers", ".", "create_milp_problem", "(", "left_ns", ",", "metabolites", ",", "Model", ",", "Variable", ",", "Constraint", ",", "Objective", ")", "LOGGER", ".", "debug", "(", "str", "(", "problem", ")", ")", "cuts", "=", "list", "(", ")", "for", "met", "in", "unconserved_mets", ":", "row", "=", "met_index", "[", "met", "]", "if", "(", "left_ns", "[", "row", "]", "==", "0.0", ")", ".", "all", "(", ")", ":", "LOGGER", ".", "debug", "(", "\"%s: singleton minimal unconservable set\"", ",", "met", ".", "id", ")", "# singleton set!", "inc_minimal", ".", "add", "(", "(", "met", ",", ")", ")", "continue", "# expect a positive mass for the unconserved metabolite", "problem", ".", "variables", "[", "met", ".", "id", "]", ".", "lb", "=", "1e-3", "status", "=", "problem", ".", "optimize", "(", ")", "while", "status", "==", "\"optimal\"", ":", "LOGGER", ".", "debug", "(", "\"%s: status %s\"", ",", "met", ".", "id", ",", "status", ")", "LOGGER", ".", "debug", "(", "\"sum of all primal values: %f\"", ",", "sum", "(", "problem", ".", "primal_values", ".", "values", "(", ")", ")", ")", "LOGGER", ".", "debug", "(", "\"sum of binary indicators: %f\"", ",", "sum", "(", "var", ".", "primal", "for", "var", "in", "indicators", ")", ")", "solution", "=", "[", "model", ".", "metabolites", ".", "get_by_id", "(", "var", ".", "name", "[", "2", ":", "]", ")", "for", "var", "in", "indicators", "if", "var", ".", "primal", ">", "0.2", "]", "LOGGER", ".", "debug", "(", "\"%s: set size %d\"", ",", "met", ".", "id", ",", "len", "(", "solution", ")", ")", "inc_minimal", ".", "add", "(", "tuple", "(", "solution", ")", ")", "if", "len", "(", "solution", ")", "==", "1", ":", "break", "cuts", ".", "append", "(", "con_helpers", ".", "add_cut", "(", "problem", ",", "indicators", ",", "len", "(", "solution", ")", "-", "1", ",", "Constraint", ")", ")", "status", "=", "problem", ".", "optimize", "(", ")", "LOGGER", ".", "debug", "(", "\"%s: last status %s\"", ",", "met", ".", "id", ",", "status", ")", "# reset", "problem", ".", "variables", "[", "met", ".", "id", "]", ".", "lb", "=", "0.0", "problem", ".", "remove", "(", "cuts", ")", "cuts", ".", "clear", "(", ")", "return", "inc_minimal" ]

[ "Detect", "inconsistent", "minimal", "net", "stoichiometries", "." ]

[ "def", "detect_energy_generating_cycles", "(", "model", ",", "metabolite_id", ")", ":", "main_comp", "=", "helpers", ".", "find_compartment_id_in_model", "(", "model", ",", "'c'", ")", "met", "=", "helpers", ".", "find_met_in_model", "(", "model", ",", "metabolite_id", ",", "main_comp", ")", "[", "0", "]", "dissipation_rxn", "=", "Reaction", "(", "'Dissipation'", ")", "if", "metabolite_id", "in", "[", "'MNXM3'", ",", "'MNXM63'", ",", "'MNXM51'", ",", "'MNXM121'", ",", "'MNXM423'", "]", ":", "# build nucleotide-type dissipation reaction", "dissipation_rxn", ".", "add_metabolites", "(", "{", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM2'", ",", "main_comp", ")", "[", "0", "]", ":", "-", "1", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM1'", ",", "main_comp", ")", "[", "0", "]", ":", "1", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM9'", ",", "main_comp", ")", "[", "0", "]", ":", "1", ",", "}", ")", "elif", "metabolite_id", "in", "[", "'MNXM6'", ",", "'MNXM10'", "]", ":", "# build nicotinamide-type dissipation reaction", "dissipation_rxn", ".", "add_metabolites", "(", "{", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM1'", ",", "main_comp", ")", "[", "0", "]", ":", "1", "}", ")", "elif", "metabolite_id", "in", "[", "'MNXM38'", ",", "'MNXM208'", ",", "'MNXM191'", ",", "'MNXM223'", ",", "'MNXM7517'", ",", "'MNXM12233'", ",", "'MNXM558'", "]", ":", "# build redox-partner-type dissipation reaction", "dissipation_rxn", ".", "add_metabolites", "(", "{", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM1'", ",", "main_comp", ")", "[", "0", "]", ":", "2", "}", ")", "elif", "metabolite_id", "==", "'MNXM21'", ":", "dissipation_rxn", ".", "add_metabolites", "(", "{", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM2'", ",", "main_comp", ")", "[", "0", "]", ":", "-", "1", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM1'", ",", "main_comp", ")", "[", "0", "]", ":", "1", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM26'", ",", "main_comp", ")", "[", "0", "]", ":", "1", ",", "}", ")", "elif", "metabolite_id", "==", "'MNXM89557'", ":", "dissipation_rxn", ".", "add_metabolites", "(", "{", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM2'", ",", "main_comp", ")", "[", "0", "]", ":", "-", "1", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM1'", ",", "main_comp", ")", "[", "0", "]", ":", "2", ",", "helpers", ".", "find_met_in_model", "(", "model", ",", "'MNXM15'", ",", "main_comp", ")", "[", "0", "]", ":", "1", ",", "}", ")", "dissipation_product", "=", "helpers", ".", "find_met_in_model", "(", "model", ",", "ENERGY_COUPLES", "[", "metabolite_id", "]", ",", "main_comp", ")", "[", "0", "]", "dissipation_rxn", ".", "add_metabolites", "(", "{", "met", ":", "-", "1", ",", "dissipation_product", ":", "1", "}", ")", "helpers", ".", "close_boundaries_sensibly", "(", "model", ")", "model", ".", "add_reactions", "(", "[", "dissipation_rxn", "]", ")", "model", ".", "objective", "=", "dissipation_rxn", "solution", "=", "model", ".", "optimize", "(", "raise_error", "=", "True", ")", "if", "solution", ".", "objective_value", ">", "0.0", ":", "return", "solution", ".", "fluxes", "[", "solution", ".", "fluxes", ".", "abs", "(", ")", ">", "0.0", "]", ".", "index", ".", "drop", "(", "[", "\"Dissipation\"", "]", ")", ".", "tolist", "(", ")", "else", ":", "return", "[", "]" ]

[ "u", "Detect", "erroneous", "energy", "-", "generating", "cycles", "for", "a", "a", "single", "metabolite", "." ]

[ "def", "find_stoichiometrically_balanced_cycles", "(", "model", ")", ":", "helpers", ".", "close_boundaries_sensibly", "(", "model", ")", "fva_result", "=", "flux_variability_analysis", "(", "model", ",", "loopless", "=", "False", ")", "return", "fva_result", ".", "index", "[", "(", "fva_result", "[", "\"minimum\"", "]", "<=", "(", "-", "1", "+", "TOLERANCE_THRESHOLD", ")", ")", "|", "(", "fva_result", "[", "\"maximum\"", "]", ">=", "(", "1", "-", "TOLERANCE_THRESHOLD", ")", ")", "]", ".", "tolist", "(", ")" ]

[ "u", "Find", "metabolic", "reactions", "in", "stoichiometrically", "balanced", "cycles", "(", "SBCs", ")", "." ]

[ "def", "find_orphans", "(", "model", ")", ":", "exchange", "=", "frozenset", "(", "model", ".", "exchanges", ")", "return", "[", "met", "for", "met", "in", "model", ".", "metabolites", "if", "(", "len", "(", "met", ".", "reactions", ")", ">", "0", ")", "and", "all", "(", "(", "not", "rxn", ".", "reversibility", ")", "and", "(", "rxn", "not", "in", "exchange", ")", "and", "(", "rxn", ".", "metabolites", "[", "met", "]", "<", "0", ")", "for", "rxn", "in", "met", ".", "reactions", ")", "]" ]

[ "Return", "metabolites", "that", "are", "only", "consumed", "in", "reactions", "." ]

[ "def", "find_metabolites_not_produced_with_open_bounds", "(", "model", ")", ":", "mets_not_produced", "=", "list", "(", ")", "helpers", ".", "open_exchanges", "(", "model", ")", "for", "met", "in", "model", ".", "metabolites", ":", "with", "model", ":", "exch", "=", "model", ".", "add_boundary", "(", "met", ",", "type", "=", "\"irrex\"", ",", "reaction_id", "=", "\"IRREX\"", ",", "lb", "=", "0", ",", "ub", "=", "1000", ")", "solution", "=", "helpers", ".", "run_fba", "(", "model", ",", "exch", ".", "id", ")", "if", "np", ".", "isnan", "(", "solution", ")", "or", "solution", "<", "TOLERANCE_THRESHOLD", ":", "mets_not_produced", ".", "append", "(", "met", ")", "return", "mets_not_produced" ]

[ "Return", "metabolites", "that", "cannot", "be", "produced", "with", "open", "exchange", "reactions", "." ]

[ "def", "find_metabolites_not_consumed_with_open_bounds", "(", "model", ")", ":", "mets_not_consumed", "=", "list", "(", ")", "helpers", ".", "open_exchanges", "(", "model", ")", "for", "met", "in", "model", ".", "metabolites", ":", "with", "model", ":", "exch", "=", "model", ".", "add_boundary", "(", "met", ",", "type", "=", "\"irrex\"", ",", "reaction_id", "=", "\"IRREX\"", ",", "lb", "=", "-", "1000", ",", "ub", "=", "0", ")", "solution", "=", "helpers", ".", "run_fba", "(", "model", ",", "exch", ".", "id", ",", "direction", "=", "\"min\"", ")", "if", "np", ".", "isnan", "(", "solution", ")", "or", "abs", "(", "solution", ")", "<", "TOLERANCE_THRESHOLD", ":", "mets_not_consumed", ".", "append", "(", "met", ")", "return", "mets_not_consumed" ]

[ "Return", "metabolites", "that", "cannot", "be", "consumed", "with", "open", "boundary", "reactions", "." ]

[ "def", "find_reactions_with_unbounded_flux_default_condition", "(", "model", ")", ":", "try", ":", "fva_result", "=", "flux_variability_analysis", "(", "model", ",", "fraction_of_optimum", "=", "1.0", ")", "except", "Infeasible", "as", "err", ":", "LOGGER", ".", "error", "(", "\"Failed to find reactions with unbounded flux \"", "\"because '{}'. This may be a bug.\"", ".", "format", "(", "err", ")", ")", "raise", "Infeasible", "(", "\"It was not possible to run flux variability \"", "\"analysis on the model. Make sure that the model \"", "\"can be solved! Check if the constraints are not \"", "\"too strict.\"", ")", "# Per reaction (row) the flux is below threshold (close to zero).", "conditionally_blocked", "=", "fva_result", ".", "loc", "[", "fva_result", ".", "abs", "(", ")", ".", "max", "(", "axis", "=", "1", ")", "<", "TOLERANCE_THRESHOLD", "]", ".", "index", ".", "tolist", "(", ")", "small", ",", "large", "=", "helpers", ".", "find_bounds", "(", "model", ")", "# Find those reactions whose flux is close to or outside of the median", "# upper or lower bound, i.e., appears unconstrained.", "unlimited_flux", "=", "fva_result", ".", "loc", "[", "np", ".", "isclose", "(", "fva_result", "[", "\"maximum\"", "]", ",", "large", ",", "atol", "=", "TOLERANCE_THRESHOLD", ")", "|", "(", "fva_result", "[", "\"maximum\"", "]", ">", "large", ")", "|", "np", ".", "isclose", "(", "fva_result", "[", "\"minimum\"", "]", ",", "small", ",", "atol", "=", "TOLERANCE_THRESHOLD", ")", "|", "(", "fva_result", "[", "\"minimum\"", "]", "<", "small", ")", "]", ".", "index", ".", "tolist", "(", ")", "try", ":", "fraction", "=", "len", "(", "unlimited_flux", ")", "/", "(", "len", "(", "model", ".", "reactions", ")", "-", "len", "(", "conditionally_blocked", ")", ")", "except", "ZeroDivisionError", ":", "LOGGER", ".", "error", "(", "\"Division by Zero! Failed to calculate the \"", "\"fraction of unbounded reactions. Does this model \"", "\"have any reactions at all?\"", ")", "raise", "ZeroDivisionError", "(", "\"It was not possible to calculate the \"", "\"fraction of unbounded reactions to \"", "\"un-blocked reactions. This may be because\"", "\"the model doesn't have any reactions at \"", "\"all or that none of the reactions can \"", "\"carry a flux larger than zero!\"", ")", "return", "unlimited_flux", ",", "fraction", ",", "conditionally_blocked" ]

[ "Return", "list", "of", "reactions", "whose", "flux", "is", "unbounded", "in", "the", "default", "condition", "." ]

[ "def", "read_tabular", "(", "filename", ",", "dtype_conversion", "=", "None", ")", ":", "if", "dtype_conversion", "is", "None", ":", "dtype_conversion", "=", "{", "}", "name", ",", "ext", "=", "filename", ".", "split", "(", "\".\"", ",", "1", ")", "ext", "=", "ext", ".", "lower", "(", ")", "# Completely empty columns are interpreted as float by default.", "dtype_conversion", "[", "\"comment\"", "]", "=", "str", "if", "\"csv\"", "in", "ext", ":", "df", "=", "pd", ".", "read_csv", "(", "filename", ",", "dtype", "=", "dtype_conversion", ",", "encoding", "=", "\"utf-8\"", ")", "elif", "\"tsv\"", "in", "ext", ":", "df", "=", "pd", ".", "read_table", "(", "filename", ",", "dtype", "=", "dtype_conversion", ",", "encoding", "=", "\"utf-8\"", ")", "elif", "\"xls\"", "in", "ext", "or", "\"xlsx\"", "in", "ext", ":", "df", "=", "pd", ".", "read_excel", "(", "filename", ",", "dtype", "=", "dtype_conversion", ",", "encoding", "=", "\"utf-8\"", ")", "# TODO: Add a function to parse ODS data into a pandas data frame.", "else", ":", "raise", "ValueError", "(", "\"Unknown file format '{}'.\"", ".", "format", "(", "ext", ")", ")", "return", "df" ]

[ "Read", "a", "tabular", "data", "file", "which", "can", "be", "CSV", "TSV", "XLS", "or", "XLSX", "." ]

[ "def", "snapshot", "(", "model", ",", "filename", ",", "pytest_args", ",", "exclusive", ",", "skip", ",", "solver", ",", "experimental", ",", "custom_tests", ",", "custom_config", ")", ":", "model_obj", ",", "sbml_ver", ",", "notifications", "=", "api", ".", "validate_model", "(", "model", ")", "if", "model_obj", "is", "None", ":", "LOGGER", ".", "critical", "(", "\"The model could not be loaded due to the following SBML errors.\"", ")", "utils", ".", "stdout_notifications", "(", "notifications", ")", "api", ".", "validation_report", "(", "model", ",", "notifications", ",", "filename", ")", "sys", ".", "exit", "(", "1", ")", "if", "not", "any", "(", "a", ".", "startswith", "(", "\"--tb\"", ")", "for", "a", "in", "pytest_args", ")", ":", "pytest_args", "=", "[", "\"--tb\"", ",", "\"no\"", "]", "+", "pytest_args", "# Add further directories to search for tests.", "pytest_args", ".", "extend", "(", "custom_tests", ")", "config", "=", "ReportConfiguration", ".", "load", "(", ")", "# Update the default test configuration with custom ones (if any).", "for", "custom", "in", "custom_config", ":", "config", ".", "merge", "(", "ReportConfiguration", ".", "load", "(", "custom", ")", ")", "model_obj", ".", "solver", "=", "solver", "_", ",", "results", "=", "api", ".", "test_model", "(", "model_obj", ",", "sbml_version", "=", "sbml_ver", ",", "results", "=", "True", ",", "pytest_args", "=", "pytest_args", ",", "skip", "=", "skip", ",", "exclusive", "=", "exclusive", ",", "experimental", "=", "experimental", ")", "with", "open", "(", "filename", ",", "\"w\"", ",", "encoding", "=", "\"utf-8\"", ")", "as", "file_handle", ":", "LOGGER", ".", "info", "(", "\"Writing snapshot report to '%s'.\"", ",", "filename", ")", "file_handle", ".", "write", "(", "api", ".", "snapshot_report", "(", "results", ",", "config", ")", ")" ]

[ "Take", "a", "snapshot", "of", "a", "model", "s", "state", "and", "generate", "a", "report", "." ]

[ "def", "history", "(", "location", ",", "model", ",", "filename", ",", "deployment", ",", "custom_config", ")", ":", "callbacks", ".", "git_installed", "(", ")", "LOGGER", ".", "info", "(", "\"Initialising history report generation.\"", ")", "if", "location", "is", "None", ":", "raise", "click", ".", "BadParameter", "(", "\"No 'location' given or configured.\"", ")", "try", ":", "repo", "=", "git", ".", "Repo", "(", ")", "except", "git", ".", "InvalidGitRepositoryError", ":", "LOGGER", ".", "critical", "(", "\"The history report requires a git repository in order to check \"", "\"the model's commit history.\"", ")", "sys", ".", "exit", "(", "1", ")", "LOGGER", ".", "info", "(", "\"Obtaining history of results from \"", "\"the deployment branch {}.\"", ".", "format", "(", "deployment", ")", ")", "repo", ".", "git", ".", "checkout", "(", "deployment", ")", "try", ":", "manager", "=", "managers", ".", "SQLResultManager", "(", "repository", "=", "repo", ",", "location", "=", "location", ")", "except", "(", "AttributeError", ",", "ArgumentError", ")", ":", "manager", "=", "managers", ".", "RepoResultManager", "(", "repository", "=", "repo", ",", "location", "=", "location", ")", "config", "=", "ReportConfiguration", ".", "load", "(", ")", "# Update the default test configuration with custom ones (if any).", "for", "custom", "in", "custom_config", ":", "config", ".", "merge", "(", "ReportConfiguration", ".", "load", "(", "custom", ")", ")", "LOGGER", ".", "info", "(", "\"Tracing the commit history.\"", ")", "history", "=", "managers", ".", "HistoryManager", "(", "repository", "=", "repo", ",", "manager", "=", "manager", ")", "history", ".", "load_history", "(", "model", ",", "skip", "=", "{", "deployment", "}", ")", "LOGGER", ".", "info", "(", "\"Composing the history report.\"", ")", "report", "=", "api", ".", "history_report", "(", "history", ",", "config", "=", "config", ")", "with", "open", "(", "filename", ",", "\"w\"", ",", "encoding", "=", "\"utf-8\"", ")", "as", "file_handle", ":", "file_handle", ".", "write", "(", "report", ")" ]

[ "Generate", "a", "report", "over", "a", "model", "s", "git", "commit", "history", "." ]

[ "def", "diff", "(", "models", ",", "filename", ",", "pytest_args", ",", "exclusive", ",", "skip", ",", "solver", ",", "experimental", ",", "custom_tests", ",", "custom_config", ")", ":", "if", "not", "any", "(", "a", ".", "startswith", "(", "\"--tb\"", ")", "for", "a", "in", "pytest_args", ")", ":", "pytest_args", "=", "[", "\"--tb\"", ",", "\"no\"", "]", "+", "pytest_args", "# Add further directories to search for tests.", "pytest_args", ".", "extend", "(", "custom_tests", ")", "config", "=", "ReportConfiguration", ".", "load", "(", ")", "# Update the default test configuration with custom ones (if any).", "for", "custom", "in", "custom_config", ":", "config", ".", "merge", "(", "ReportConfiguration", ".", "load", "(", "custom", ")", ")", "# Build the diff report specific data structure", "diff_results", "=", "dict", "(", ")", "model_and_model_ver_tuple", "=", "list", "(", ")", "for", "model_path", "in", "models", ":", "try", ":", "model_filename", "=", "os", ".", "path", ".", "basename", "(", "model_path", ")", "diff_results", ".", "setdefault", "(", "model_filename", ",", "dict", "(", ")", ")", "model", ",", "model_ver", ",", "notifications", "=", "api", ".", "validate_model", "(", "model_path", ")", "if", "model", "is", "None", ":", "head", ",", "tail", "=", "os", ".", "path", ".", "split", "(", "filename", ")", "report_path", "=", "os", ".", "path", ".", "join", "(", "head", ",", "'{}_structural_report.html'", ".", "format", "(", "model_filename", ")", ")", "api", ".", "validation_report", "(", "model_path", ",", "notifications", ",", "report_path", ")", "LOGGER", ".", "critical", "(", "\"The model {} could not be loaded due to SBML errors \"", "\"reported in {}.\"", ".", "format", "(", "model_filename", ",", "report_path", ")", ")", "continue", "model", ".", "solver", "=", "solver", "model_and_model_ver_tuple", ".", "append", "(", "(", "model", ",", "model_ver", ")", ")", "except", "(", "IOError", ",", "SBMLError", ")", ":", "LOGGER", ".", "debug", "(", "exc_info", "=", "True", ")", "LOGGER", ".", "warning", "(", "\"An error occurred while loading the model '%s'. \"", "\"Skipping.\"", ",", "model_filename", ")", "# Abort the diff report unless at least two models can be loaded", "# successfully.", "if", "len", "(", "model_and_model_ver_tuple", ")", "<", "2", ":", "LOGGER", ".", "critical", "(", "\"Out of the %d provided models only %d could be loaded. Please, \"", "\"check if the models that could not be loaded are valid SBML. \"", "\"Aborting.\"", ",", "len", "(", "models", ")", ",", "len", "(", "model_and_model_ver_tuple", ")", ")", "sys", ".", "exit", "(", "1", ")", "# Running pytest in individual processes to avoid interference", "partial_test_diff", "=", "partial", "(", "_test_diff", ",", "pytest_args", "=", "pytest_args", ",", "skip", "=", "skip", ",", "exclusive", "=", "exclusive", ",", "experimental", "=", "experimental", ")", "pool", "=", "Pool", "(", "min", "(", "len", "(", "models", ")", ",", "cpu_count", "(", ")", ")", ")", "results", "=", "pool", ".", "map", "(", "partial_test_diff", ",", "model_and_model_ver_tuple", ")", "for", "model_path", ",", "result", "in", "zip", "(", "models", ",", "results", ")", ":", "model_filename", "=", "os", ".", "path", ".", "basename", "(", "model_path", ")", "diff_results", "[", "model_filename", "]", "=", "result", "with", "open", "(", "filename", ",", "\"w\"", ",", "encoding", "=", "\"utf-8\"", ")", "as", "file_handle", ":", "LOGGER", ".", "info", "(", "\"Writing diff report to '%s'.\"", ",", "filename", ")", "file_handle", ".", "write", "(", "api", ".", "diff_report", "(", "diff_results", ",", "config", ")", ")" ]

[ "Take", "a", "snapshot", "of", "all", "the", "supplied", "models", "and", "generate", "a", "diff", "report", "." ]

[ "def", "build_branch_structure", "(", "self", ",", "model", ",", "skip", ")", ":", "self", ".", "_history", "=", "dict", "(", ")", "self", ".", "_history", "[", "\"commits\"", "]", "=", "commits", "=", "dict", "(", ")", "self", ".", "_history", "[", "\"branches\"", "]", "=", "branches", "=", "dict", "(", ")", "for", "branch", "in", "self", ".", "_repo", ".", "refs", ":", "LOGGER", ".", "debug", "(", "branch", ".", "name", ")", "if", "branch", ".", "name", "in", "skip", ":", "continue", "branches", "[", "branch", ".", "name", "]", "=", "branch_history", "=", "list", "(", ")", "latest", "=", "branch", ".", "commit", "history", "=", "[", "latest", "]", "+", "list", "(", "latest", ".", "iter_parents", "(", ")", ")", "for", "commit", "in", "history", ":", "# Find model in committed files.", "if", "not", "is_modified", "(", "model", ",", "commit", ")", ":", "LOGGER", ".", "info", "(", "\"The model was not modified in commit '{}'. \"", "\"Skipping.\"", ".", "format", "(", "commit", ")", ")", "continue", "branch_history", ".", "append", "(", "commit", ".", "hexsha", ")", "if", "commit", ".", "hexsha", "not", "in", "commits", ":", "commits", "[", "commit", ".", "hexsha", "]", "=", "sub", "=", "dict", "(", ")", "sub", "[", "\"timestamp\"", "]", "=", "commit", ".", "authored_datetime", ".", "isoformat", "(", "\" \"", ")", "sub", "[", "\"author\"", "]", "=", "commit", ".", "author", ".", "name", "sub", "[", "\"email\"", "]", "=", "commit", ".", "author", ".", "email", "LOGGER", ".", "debug", "(", "\"%s\"", ",", "json", ".", "dumps", "(", "self", ".", "_history", ",", "indent", "=", "2", ")", ")" ]

[ "Inspect", "and", "record", "the", "repo", "s", "branches", "and", "their", "history", "." ]

[ "def", "load_history", "(", "self", ",", "model", ",", "skip", "=", "{", "\"gh-pages\"", "}", ")", ":", "if", "self", ".", "_history", "is", "None", ":", "self", ".", "build_branch_structure", "(", "model", ",", "skip", ")", "self", ".", "_results", "=", "dict", "(", ")", "all_commits", "=", "list", "(", "self", ".", "_history", "[", "\"commits\"", "]", ")", "for", "commit", "in", "all_commits", ":", "try", ":", "self", ".", "_results", "[", "commit", "]", "=", "self", ".", "manager", ".", "load", "(", "commit", ")", "except", "(", "IOError", ",", "NoResultFound", ")", "as", "err", ":", "LOGGER", ".", "error", "(", "\"Could not load result '%s'.\"", ",", "commit", ")", "LOGGER", ".", "debug", "(", "\"%s\"", ",", "str", "(", "err", ")", ")" ]

[ "Load", "the", "entire", "results", "history", "into", "memory", "." ]

[ "def", "get_result", "(", "self", ",", "commit", ",", "default", "=", "MemoteResult", "(", ")", ")", ":", "assert", "self", ".", "_results", "is", "not", "None", ",", "\"Please call the method `load_history` first.\"", "return", "self", ".", "_results", ".", "get", "(", "commit", ",", "default", ")" ]

[ "Return", "an", "individual", "result", "from", "the", "history", "if", "it", "exists", "." ]

[ "def", "absolute_extreme_coefficient_ratio", "(", "model", ")", ":", "s_matrix", ",", "_", ",", "_", "=", "con_helpers", ".", "stoichiometry_matrix", "(", "model", ".", "metabolites", ",", "model", ".", "reactions", ")", "abs_matrix", "=", "np", ".", "abs", "(", "s_matrix", ")", "return", "abs_matrix", ".", "max", "(", ")", ",", "abs_matrix", "[", "abs_matrix", ">", "0", "]", ".", "min", "(", ")" ]

[ "Return", "the", "maximum", "and", "minimum", "absolute", "non", "-", "zero", "coefficients", "." ]

[ "def", "number_independent_conservation_relations", "(", "model", ")", ":", "s_matrix", ",", "_", ",", "_", "=", "con_helpers", ".", "stoichiometry_matrix", "(", "model", ".", "metabolites", ",", "model", ".", "reactions", ")", "ln_matrix", "=", "con_helpers", ".", "nullspace", "(", "s_matrix", ".", "T", ")", "return", "ln_matrix", ".", "shape", "[", "1", "]" ]

[ "Return", "the", "number", "of", "conserved", "metabolite", "pools", "." ]

[ "def", "matrix_rank", "(", "model", ")", ":", "s_matrix", ",", "_", ",", "_", "=", "con_helpers", ".", "stoichiometry_matrix", "(", "model", ".", "metabolites", ",", "model", ".", "reactions", ")", "return", "con_helpers", ".", "rank", "(", "s_matrix", ")" ]

[ "Return", "the", "rank", "of", "the", "model", "s", "stoichiometric", "matrix", "." ]

[ "def", "degrees_of_freedom", "(", "model", ")", ":", "s_matrix", ",", "_", ",", "_", "=", "con_helpers", ".", "stoichiometry_matrix", "(", "model", ".", "metabolites", ",", "model", ".", "reactions", ")", "return", "s_matrix", ".", "shape", "[", "1", "]", "-", "matrix_rank", "(", "model", ")" ]

[ "Return", "the", "degrees", "of", "freedom", "i", ".", "e", ".", "number", "of", "free", "variables", "." ]

[ "def", "load", "(", "self", ",", "model", ")", ":", "self", ".", "load_medium", "(", "model", ")", "self", ".", "load_essentiality", "(", "model", ")", "self", ".", "load_growth", "(", "model", ")", "# self.load_experiment(config.config.get(\"growth\"), model)", "return", "self" ]

[ "Load", "all", "information", "from", "an", "experimental", "configuration", "file", "." ]

[ "def", "validate", "(", "self", ")", ":", "validator", "=", "Draft4Validator", "(", "self", ".", "SCHEMA", ")", "if", "not", "validator", ".", "is_valid", "(", "self", ".", "config", ")", ":", "for", "err", "in", "validator", ".", "iter_errors", "(", "self", ".", "config", ")", ":", "LOGGER", ".", "error", "(", "str", "(", "err", ".", "message", ")", ")", "validator", ".", "validate", "(", "self", ".", "config", ")" ]

[ "Validate", "the", "configuration", "file", "." ]

[ "def", "load_medium", "(", "self", ",", "model", ")", ":", "media", "=", "self", ".", "config", ".", "get", "(", "\"medium\"", ")", "if", "media", "is", "None", ":", "return", "definitions", "=", "media", ".", "get", "(", "\"definitions\"", ")", "if", "definitions", "is", "None", "or", "len", "(", "definitions", ")", "==", "0", ":", "return", "path", "=", "self", ".", "get_path", "(", "media", ",", "join", "(", "\"data\"", ",", "\"experimental\"", ",", "\"media\"", ")", ")", "for", "medium_id", ",", "medium", "in", "iteritems", "(", "definitions", ")", ":", "if", "medium", "is", "None", ":", "medium", "=", "dict", "(", ")", "filename", "=", "medium", ".", "get", "(", "\"filename\"", ")", "if", "filename", "is", "None", ":", "filename", "=", "join", "(", "path", ",", "\"{}.csv\"", ".", "format", "(", "medium_id", ")", ")", "elif", "not", "isabs", "(", "filename", ")", ":", "filename", "=", "join", "(", "path", ",", "filename", ")", "tmp", "=", "Medium", "(", "identifier", "=", "medium_id", ",", "obj", "=", "medium", ",", "filename", "=", "filename", ")", "tmp", ".", "load", "(", ")", "tmp", ".", "validate", "(", "model", ")", "self", ".", "media", "[", "medium_id", "]", "=", "tmp" ]

[ "Load", "and", "validate", "all", "media", "." ]

[ "def", "load_essentiality", "(", "self", ",", "model", ")", ":", "data", "=", "self", ".", "config", ".", "get", "(", "\"essentiality\"", ")", "if", "data", "is", "None", ":", "return", "experiments", "=", "data", ".", "get", "(", "\"experiments\"", ")", "if", "experiments", "is", "None", "or", "len", "(", "experiments", ")", "==", "0", ":", "return", "path", "=", "self", ".", "get_path", "(", "data", ",", "join", "(", "\"data\"", ",", "\"experimental\"", ",", "\"essentiality\"", ")", ")", "for", "exp_id", ",", "exp", "in", "iteritems", "(", "experiments", ")", ":", "if", "exp", "is", "None", ":", "exp", "=", "dict", "(", ")", "filename", "=", "exp", ".", "get", "(", "\"filename\"", ")", "if", "filename", "is", "None", ":", "filename", "=", "join", "(", "path", ",", "\"{}.csv\"", ".", "format", "(", "exp_id", ")", ")", "elif", "not", "isabs", "(", "filename", ")", ":", "filename", "=", "join", "(", "path", ",", "filename", ")", "experiment", "=", "EssentialityExperiment", "(", "identifier", "=", "exp_id", ",", "obj", "=", "exp", ",", "filename", "=", "filename", ")", "if", "experiment", ".", "medium", "is", "not", "None", ":", "assert", "experiment", ".", "medium", "in", "self", ".", "media", ",", "\"Experiment '{}' has an undefined medium '{}'.\"", ".", "format", "(", "exp_id", ",", "experiment", ".", "medium", ")", "experiment", ".", "medium", "=", "self", ".", "media", "[", "experiment", ".", "medium", "]", "experiment", ".", "load", "(", ")", "experiment", ".", "validate", "(", "model", ")", "self", ".", "essentiality", "[", "exp_id", "]", "=", "experiment" ]

[ "Load", "and", "validate", "all", "data", "files", "." ]

[ "def", "load_growth", "(", "self", ",", "model", ")", ":", "data", "=", "self", ".", "config", ".", "get", "(", "\"growth\"", ")", "if", "data", "is", "None", ":", "return", "experiments", "=", "data", ".", "get", "(", "\"experiments\"", ")", "if", "experiments", "is", "None", "or", "len", "(", "experiments", ")", "==", "0", ":", "return", "path", "=", "self", ".", "get_path", "(", "data", ",", "join", "(", "\"data\"", ",", "\"experimental\"", ",", "\"growth\"", ")", ")", "for", "exp_id", ",", "exp", "in", "iteritems", "(", "experiments", ")", ":", "if", "exp", "is", "None", ":", "exp", "=", "dict", "(", ")", "filename", "=", "exp", ".", "get", "(", "\"filename\"", ")", "if", "filename", "is", "None", ":", "filename", "=", "join", "(", "path", ",", "\"{}.csv\"", ".", "format", "(", "exp_id", ")", ")", "elif", "not", "isabs", "(", "filename", ")", ":", "filename", "=", "join", "(", "path", ",", "filename", ")", "growth", "=", "GrowthExperiment", "(", "identifier", "=", "exp_id", ",", "obj", "=", "exp", ",", "filename", "=", "filename", ")", "if", "growth", ".", "medium", "is", "not", "None", ":", "assert", "growth", ".", "medium", "in", "self", ".", "media", ",", "\"Growth-experiment '{}' has an undefined medium '{}'.\"", "\"\"", ".", "format", "(", "exp_id", ",", "growth", ".", "medium", ")", "growth", ".", "medium", "=", "self", ".", "media", "[", "growth", ".", "medium", "]", "growth", ".", "load", "(", ")", "growth", ".", "validate", "(", "model", ")", "self", ".", "growth", "[", "exp_id", "]", "=", "growth" ]

[ "Load", "and", "validate", "all", "data", "files", "." ]

[ "def", "get_path", "(", "self", ",", "obj", ",", "default", ")", ":", "path", "=", "obj", ".", "get", "(", "\"path\"", ")", "if", "path", "is", "None", ":", "path", "=", "join", "(", "self", ".", "_base", ",", "default", ")", "if", "not", "isabs", "(", "path", ")", ":", "path", "=", "join", "(", "self", ".", "_base", ",", "path", ")", "return", "path" ]

[ "Return", "a", "relative", "or", "absolute", "path", "to", "experimental", "data", "." ]

[ "def", "find_components_without_annotation", "(", "model", ",", "components", ")", ":", "return", "[", "elem", "for", "elem", "in", "getattr", "(", "model", ",", "components", ")", "if", "elem", ".", "annotation", "is", "None", "or", "len", "(", "elem", ".", "annotation", ")", "==", "0", "]" ]

[ "Find", "model", "components", "with", "empty", "annotation", "attributes", "." ]