Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "equation", "(", "self", ")", ":", "mat", "=", "np", ".", "empty", "(", "(", "self", ".", "nunknowns", ",", "self", ".", "model", ".", "neq", ")", ")", "rhs", "=", "np", ".", "zeros", "(", "self", ".", "nunknowns", ")", "# Needs to be initialized to zero", "for", "icp", "in", "range", "(", "self", ".", "ncp", ")", ":", "istart", "=", "icp", "*", "self", ".", "nlayers", "ieq", "=", "0", "for", "e", "in", "self", ".", "model", ".", "elementlist", ":", "if", "e", ".", "nunknowns", ">", "0", ":", "qxin", ",", "qyin", "=", "e", ".", "disvecinflayers", "(", "self", ".", "xcin", "[", "icp", "]", ",", "self", ".", "ycin", "[", "icp", "]", ",", "self", ".", "layers", ",", "aq", "=", "self", ".", "aqin", ")", "qxout", ",", "qyout", "=", "e", ".", "disvecinflayers", "(", "self", ".", "xcout", "[", "icp", "]", ",", "self", ".", "ycout", "[", "icp", "]", ",", "self", ".", "layers", ",", "aq", "=", "self", ".", "aqout", ")", "mat", "[", "istart", ":", "istart", "+", "self", ".", "nlayers", ",", "ieq", ":", "ieq", "+", "e", ".", "nunknowns", "]", "=", "(", "qxin", "-", "qxout", ")", "*", "self", ".", "cosnorm", "[", "icp", "]", "+", "(", "qyin", "-", "qyout", ")", "*", "self", ".", "sinnorm", "[", "icp", "]", "ieq", "+=", "e", ".", "nunknowns", "else", ":", "qxin", ",", "qyin", "=", "e", ".", "disveclayers", "(", "self", ".", "xcin", "[", "icp", "]", ",", "self", ".", "ycin", "[", "icp", "]", ",", "self", ".", "layers", ",", "aq", "=", "self", ".", "aqin", ")", "qxout", ",", "qyout", "=", "e", ".", "disveclayers", "(", "self", ".", "xcout", "[", "icp", "]", ",", "self", ".", "ycout", "[", "icp", "]", ",", "self", ".", "layers", ",", "aq", "=", "self", ".", "aqout", ")", "rhs", "[", "istart", ":", "istart", "+", "self", ".", "nlayers", "]", "-=", "(", "qxin", "-", "qxout", ")", "*", "self", ".", "cosnorm", "[", "icp", "]", "+", "(", "qyin", "-", "qyout", ")", "*", "self", ".", "sinnorm", "[", "icp", "]", "return", "mat", ",", "rhs" ]

[ "Mix", "-", "in", "class", "that", "returns", "matrix", "rows", "for", "difference", "in", "head", "between", "inside", "and", "outside", "equals", "zeros", "Returns", "matrix", "part", "(", "nunknowns", "neq", ")", "Returns", "rhs", "part", "nunknowns" ]

[ "def", "p_extr_lic_name_value_1", "(", "self", ",", "p", ")", ":", "if", "six", ".", "PY2", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", ".", "decode", "(", "encoding", "=", "'utf-8'", ")", "else", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]" ]

[ "extr_lic_name_value", ":", "LINE" ]

[ "def", "env_updated", "(", "self", ",", "kb_app", ",", "sphinx_app", ":", "Sphinx", ",", "sphinx_env", ":", "BuildEnvironment", ",", "resource", ")", ":", "docname", "=", "resource", ".", "docname", "srcdir", "=", "sphinx_app", ".", "env", ".", "srcdir", "source_imgpath", "=", "self", ".", "source_filename", "(", "docname", ",", "srcdir", ")", "# Copy the image to the Sphinx build directory", "build_dir", "=", "sphinx_app", ".", "outdir", "docpath", "=", "Path", "(", "docname", ")", "parent", "=", "docpath", ".", "parent", "target_imgpath", "=", "str", "(", "Path", "(", "build_dir", ",", "parent", ",", "self", ".", "filename", ")", ")", "# Does the target dir exist yet in the build dir? Probably not. If", "# not, make it", "target_dir", "=", "Path", "(", "build_dir", ",", "parent", ")", "if", "not", "target_dir", ".", "exists", "(", ")", ":", "target_dir", ".", "mkdir", "(", "parents", "=", "True", ",", "exist_ok", "=", "True", ")", "shutil", ".", "copy", "(", "source_imgpath", ",", "target_imgpath", ")" ]

[ "Make", "images", "and", "enter", "them", "in", "Sphinx", "s", "output", "writer" ]

[ "def", "TR", "(", "self", ",", "*", "*", "kwargs", ")", ":", "#pragma: no cover", "if", "hasattr", "(", "self", ",", "'_TR'", ")", ":", "return", "self", ".", "_TR", "(", "rperi", ",", "rap", ")", "=", "self", ".", "calcRapRperi", "(", "*", "*", "kwargs", ")", "if", "nu", ".", "fabs", "(", "rap", "-", "rperi", ")", "/", "rap", "<", "10.", "**", "-", "4.", ":", "#Rough limit", "self", ".", "_TR", "=", "2.", "*", "m", ".", "pi", "/", "epifreq", "(", "self", ".", "_pot", ",", "self", ".", "_R", ",", "use_physical", "=", "False", ")", "return", "self", ".", "_TR", "Rmean", "=", "m", ".", "exp", "(", "(", "m", ".", "log", "(", "rperi", ")", "+", "m", ".", "log", "(", "rap", ")", ")", "/", "2.", ")", "EL", "=", "self", ".", "calcEL", "(", "*", "*", "kwargs", ")", "E", ",", "L", "=", "EL", "TR", "=", "0.", "if", "Rmean", ">", "rperi", ":", "TR", "+=", "integrate", ".", "quadrature", "(", "_TRAxiIntegrandSmall", ",", "0.", ",", "m", ".", "sqrt", "(", "Rmean", "-", "rperi", ")", ",", "args", "=", "(", "E", ",", "L", ",", "self", ".", "_pot", ",", "rperi", ")", ",", "*", "*", "kwargs", ")", "[", "0", "]", "if", "Rmean", "<", "rap", ":", "TR", "+=", "integrate", ".", "quadrature", "(", "_TRAxiIntegrandLarge", ",", "0.", ",", "m", ".", "sqrt", "(", "rap", "-", "Rmean", ")", ",", "args", "=", "(", "E", ",", "L", ",", "self", ".", "_pot", ",", "rap", ")", ",", "*", "*", "kwargs", ")", "[", "0", "]", "self", ".", "_TR", "=", "2.", "*", "TR", "return", "self", ".", "_TR" ]

[ "NAME", ":", "TR", "PURPOSE", ":", "Calculate", "the", "radial", "period", "for", "a", "power", "-", "law", "rotation", "curve", "INPUT", ":", "scipy", ".", "integrate", ".", "quadrature", "keywords", "OUTPUT", ":", "T_R", "(", "R", "vT", "vT", ")", "*", "vc", "/", "ro", "+", "estimate", "of", "the", "error", "HISTORY", ":", "2010", "-", "12", "-", "01", "-", "Written", "-", "Bovy", "(", "NYU", ")" ]

[ "def", "get_parent_gradebooks", "(", "self", ",", "gradebook_id", ")", ":", "# Implemented from template for", "# osid.resource.BinHierarchySession.get_parent_bins", "if", "self", ".", "_catalog_session", "is", "not", "None", ":", "return", "self", ".", "_catalog_session", ".", "get_parent_catalogs", "(", "catalog_id", "=", "gradebook_id", ")", "return", "GradebookLookupSession", "(", "self", ".", "_proxy", ",", "self", ".", "_runtime", ")", ".", "get_gradebooks_by_ids", "(", "list", "(", "self", ".", "get_parent_gradebook_ids", "(", "gradebook_id", ")", ")", ")" ]

[ "Gets", "the", "parents", "of", "the", "given", "gradebook", "." ]

[ "def", "_dispatch_cmd", "(", "self", ",", "handler", ",", "argv", ")", ":", "co_argcount", "=", "handler", ".", "__func__", ".", "__code__", ".", "co_argcount", "if", "co_argcount", "==", "2", ":", "# handler ::= do_foo(self, argv)", "return", "handler", "(", "argv", ")", "elif", "co_argcount", ">=", "3", ":", "# handler ::= do_foo(self, subcmd, opts, ...)", "try", ":", "optparser", "=", "handler", ".", "optparser", "except", "AttributeError", ":", "optparser", "=", "handler", ".", "__func__", ".", "optparser", "=", "SubCmdOptionParser", "(", ")", "assert", "isinstance", "(", "optparser", ",", "SubCmdOptionParser", ")", "# apply subcommand options' defaults from config files, if any.", "subcmd", "=", "handler", ".", "__name__", ".", "split", "(", "'do_'", ",", "1", ")", "[", "1", "]", "optparser", ".", "set_defaults", "(", "*", "*", "self", ".", "get_option_defaults", "(", "subcmd", ")", ")", "optparser", ".", "set_cmdln_info", "(", "self", ",", "argv", "[", "0", "]", ")", "try", ":", "opts", ",", "args", "=", "optparser", ".", "parse_args", "(", "argv", "[", "1", ":", "]", ")", "except", "StopOptionProcessing", ":", "#TODO: this doesn't really fly for a replacement of", "# optparse.py behaviour, does it?", "return", "0", "# Normal command termination", "try", ":", "return", "handler", "(", "argv", "[", "0", "]", ",", "opts", ",", "*", "args", ")", "except", "TypeError", ":", "_", ",", "ex", ",", "_", "=", "sys", ".", "exc_info", "(", ")", "# Some TypeError's are user errors:", "# do_foo() takes at least 4 arguments (3 given)", "# do_foo() takes at most 5 arguments (6 given)", "# do_foo() takes exactly 5 arguments (6 given)", "# do_foo() takes exactly 5 positional arguments (6 given)", "# Raise CmdlnUserError for these with a suitably", "# massaged error message.", "tb", "=", "sys", ".", "exc_info", "(", ")", "[", "2", "]", "# the traceback object", "if", "tb", ".", "tb_next", "is", "not", "None", ":", "# If the traceback is more than one level deep, then the", "# TypeError do *not* happen on the \"handler(...)\" call", "# above. In that we don't want to handle it specially", "# here: it would falsely mask deeper code errors.", "raise", "msg", "=", "ex", ".", "args", "[", "0", "]", "match", "=", "_INCORRECT_NUM_ARGS_RE", ".", "search", "(", "msg", ")", "if", "match", ":", "msg", "=", "list", "(", "match", ".", "groups", "(", ")", ")", "msg", "[", "1", "]", "=", "int", "(", "msg", "[", "1", "]", ")", "-", "3", "if", "msg", "[", "1", "]", "==", "1", ":", "msg", "[", "2", "]", "=", "msg", "[", "2", "]", ".", "replace", "(", "\"arguments\"", ",", "\"argument\"", ")", "msg", "[", "3", "]", "=", "int", "(", "msg", "[", "3", "]", ")", "-", "3", "msg", "=", "''", ".", "join", "(", "map", "(", "str", ",", "msg", ")", ")", "raise", "CmdlnUserError", "(", "msg", ")", "else", ":", "raise", "else", ":", "raise", "CmdlnError", "(", "\"incorrect argcount for %s(): takes %d, must \"", "\"take 2 for 'argv' signature or 3+ for 'opts' \"", "\"signature\"", "%", "(", "handler", ".", "__name__", ",", "co_argcount", ")", ")" ]

[ "Introspect", "sub", "-", "command", "handler", "signature", "to", "determine", "how", "to", "dispatch", "the", "command", ".", "The", "raw", "handler", "provided", "by", "the", "base", "RawCmdln", "class", "is", "still", "supported", ":" ]

[ "def", "_add_gradient_scalar", "(", "self", ",", "name", ":", "str", ",", "scalar_value", ")", "->", "None", ":", "tag", "=", "self", ".", "name", "+", "'/gradients/'", "+", "name", "self", ".", "tbwriter", ".", "add_scalar", "(", "tag", "=", "tag", ",", "scalar_value", "=", "scalar_value", ",", "global_step", "=", "self", ".", "iteration", ")" ]

[ "Writes", "a", "single", "scalar", "value", "for", "a", "gradient", "statistic", "to", "Tensorboard", "." ]

[ "def", "add_idle", "(", "self", ",", "callback", ",", "*", "args", ",", "*", "*", "kwds", ")", ":", "self", ".", "idlers", ".", "append", "(", "(", "callback", ",", "args", ",", "kwds", ")", ")" ]

[ "Add", "an", "idle", "callback", "." ]

[ "def", "line_cross", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ",", "x4", ",", "y4", ")", ":", "# out of the rect", "if", "min", "(", "x1", ",", "x2", ")", ">", "max", "(", "x3", ",", "x4", ")", "or", "max", "(", "x1", ",", "x2", ")", "<", "min", "(", "x3", ",", "x4", ")", "or", "min", "(", "y1", ",", "y2", ")", ">", "max", "(", "y3", ",", "y4", ")", "or", "max", "(", "y1", ",", "y2", ")", "<", "min", "(", "y3", ",", "y4", ")", ":", "return", "False", "# same slope rate", "if", "(", "(", "y1", "-", "y2", ")", "*", "(", "x3", "-", "x4", ")", "==", "(", "x1", "-", "x2", ")", "*", "(", "y3", "-", "y4", ")", ")", ":", "return", "False", "if", "cross_product", "(", "x3", ",", "y3", ",", "x2", ",", "y2", ",", "x4", ",", "y4", ")", "*", "cross_product", "(", "x3", ",", "y3", ",", "x4", ",", "y4", ",", "x1", ",", "y1", ")", "<", "0", "or", "cross_product", "(", "x1", ",", "y1", ",", "x4", ",", "y4", ",", "x2", ",", "y2", ")", "*", "cross_product", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ")", "<", "0", ":", "return", "False", "# get collide point", "b1", "=", "(", "y2", "-", "y1", ")", "*", "x1", "+", "(", "x1", "-", "x2", ")", "*", "y1", "b2", "=", "(", "y4", "-", "y3", ")", "*", "x3", "+", "(", "x3", "-", "x4", ")", "*", "y3", "D", "=", "(", "x2", "-", "x1", ")", "*", "(", "y4", "-", "y3", ")", "-", "(", "x4", "-", "x3", ")", "*", "(", "y2", "-", "y1", ")", "D1", "=", "b2", "*", "(", "x2", "-", "x1", ")", "-", "b1", "*", "(", "x4", "-", "x3", ")", "D2", "=", "b2", "*", "(", "y2", "-", "y1", ")", "-", "b1", "*", "(", "y4", "-", "y3", ")", "return", "P", "(", "D1", "/", "D", ",", "D2", "/", "D", ")" ]

[ "判断两条线段是否交叉" ]

[ "def", "add_sdfile", "(", "self", ",", "sdfile", ")", ":", "if", "not", "isinstance", "(", "sdfile", ",", "SDfile", ")", ":", "raise", "ValueError", "(", "'Not a SDfile type: \"{}\"'", ".", "format", "(", "type", "(", "sdfile", ")", ")", ")", "for", "entry_id", "in", "sdfile", ":", "self", ".", "add_molfile", "(", "molfile", "=", "sdfile", "[", "entry_id", "]", "[", "'molfile'", "]", ",", "data", "=", "sdfile", "[", "entry_id", "]", "[", "'data'", "]", ")" ]

[ "Add", "new", "SDfile", "to", "current", "SDfile", "." ]

[ "def", "fancy", "(", "cls", ",", "contains", ",", "max_tries", ",", "inner", "=", "False", ",", "keepcase", "=", "False", ")", ":", "contains", "=", "contains", "if", "keepcase", "else", "contains", ".", "lower", "(", ")", "if", "not", "set", "(", "contains", ")", ".", "issubset", "(", "base58", ".", "alphabet", ")", ":", "raise", "ValueError", "(", "\"Cannot find contained phrase '{}' as it contains non-b58 characters\"", ".", "format", "(", "contains", ")", ")", "basenum", "=", "os", ".", "urandom", "(", "26", ")", "for", "i", "in", "range", "(", "max_tries", ")", ":", "k", "=", "nacl", ".", "public", ".", "PrivateKey", "(", "basenum", "+", "i", ".", "to_bytes", "(", "6", ",", "'big'", ")", ")", "ukey", "=", "cls", "(", "k", ".", "public_key", ",", "k", ")", "test_uid", "=", "ukey", ".", "userID", "if", "keepcase", "else", "ukey", ".", "userID", ".", "lower", "(", ")", "if", "test_uid", ".", "startswith", "(", "contains", ")", "or", "test_uid", ".", "endswith", "(", "contains", ")", "or", "(", "inner", "and", "contains", "in", "test_uid", ")", ":", "return", "ukey", "else", ":", "raise", "ValueError", "(", "\"Could not create key with desired prefix '{}' in {} attempts.\"", ".", "format", "(", "prefix", ",", "max_tries", ")", ")" ]

[ "Try", "to", "create", "a", "key", "with", "a", "chosen", "prefix", "by", "starting", "with", "a", "26", "-", "bit", "urandom", "number", "and", "appending", "with", "8", "-", "byte", "integers", "until", "prefix", "matches", ".", "This", "function", "is", "naive", "but", "has", "a", "max_tries", "argument", "which", "will", "abort", "when", "reached", "with", "a", "ValueError", ".", "TODO", ":", "make", "this", "smarter", "in", "general", ".", "Variable", "byte", "length", "according", "to", "expected", "attempts", "warnings", "of", "expected", "duration", "of", "iteration", "etc", ".", "TODO", ":", "Implement", "multiprocessing", "to", "use", "poly", "-", "core", "machines", "fully", ":", "-", "Shared", "list", "each", "process", "checks", "if", "empty", "every", "cycle", "aborts", "if", "contains", "a", "value", ".", "-", "Successful", "values", "are", "pushed", "to", "list", "cancelling", "all", "processes?", "-", "Server", "waits", "on", "all", "child", "processes", "then", "expects", "a", "list?", "-", "Ensure", "child", "processes", "start", "with", "different", "random", "base", "numbers", "to", "avoid", "duplication?", "-", "Investigate", "server", "/", "manager", "aspect", "of", "multiprocessing", ";", "mini", "-", "clustering?" ]

[ "def", "show_network", "(", "self", ")", ":", "if", "(", "(", "self", ".", "_ccore_network_pointer", "is", "not", "None", ")", "and", "(", "self", ".", "_osc_conn", "is", "None", ")", ")", ":", "self", ".", "_osc_conn", "=", "sync_connectivity_matrix", "(", "self", ".", "_ccore_network_pointer", ")", "dimension", "=", "len", "(", "self", ".", "_osc_loc", "[", "0", "]", ")", "if", "(", "(", "dimension", "!=", "3", ")", "and", "(", "dimension", "!=", "2", ")", ")", ":", "raise", "NameError", "(", "'Network that is located in different from 2-d and 3-d dimensions can not be represented'", ")", "from", "matplotlib", ".", "font_manager", "import", "FontProperties", "from", "matplotlib", "import", "rcParams", "rcParams", "[", "'font.sans-serif'", "]", "=", "[", "'Arial'", "]", "rcParams", "[", "'font.size'", "]", "=", "12", "fig", "=", "plt", ".", "figure", "(", ")", "axes", "=", "None", "if", "(", "dimension", "==", "2", ")", ":", "axes", "=", "fig", ".", "add_subplot", "(", "111", ")", "elif", "(", "dimension", "==", "3", ")", ":", "axes", "=", "fig", ".", "gca", "(", "projection", "=", "'3d'", ")", "surface_font", "=", "FontProperties", "(", ")", "surface_font", ".", "set_name", "(", "'Arial'", ")", "surface_font", ".", "set_size", "(", "'12'", ")", "for", "i", "in", "range", "(", "0", ",", "self", ".", "_num_osc", ",", "1", ")", ":", "if", "(", "dimension", "==", "2", ")", ":", "axes", ".", "plot", "(", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "'bo'", ")", "if", "(", "self", ".", "_conn_represent", "==", "conn_represent", ".", "MATRIX", ")", ":", "for", "j", "in", "range", "(", "i", ",", "self", ".", "_num_osc", ",", "1", ")", ":", "# draw connection between two points only one time\r", "if", "(", "self", ".", "has_connection", "(", "i", ",", "j", ")", "==", "True", ")", ":", "axes", ".", "plot", "(", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "0", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "1", "]", "]", ",", "'b-'", ",", "linewidth", "=", "0.5", ")", "else", ":", "for", "j", "in", "self", ".", "get_neighbors", "(", "i", ")", ":", "if", "(", "(", "self", ".", "has_connection", "(", "i", ",", "j", ")", "==", "True", ")", "and", "(", "i", ">", "j", ")", ")", ":", "# draw connection between two points only one time\r", "axes", ".", "plot", "(", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "0", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "1", "]", "]", ",", "'b-'", ",", "linewidth", "=", "0.5", ")", "elif", "(", "dimension", "==", "3", ")", ":", "axes", ".", "scatter", "(", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "self", ".", "_osc_loc", "[", "i", "]", "[", "2", "]", ",", "c", "=", "'b'", ",", "marker", "=", "'o'", ")", "if", "(", "self", ".", "_conn_represent", "==", "conn_represent", ".", "MATRIX", ")", ":", "for", "j", "in", "range", "(", "i", ",", "self", ".", "_num_osc", ",", "1", ")", ":", "# draw connection between two points only one time\r", "if", "(", "self", ".", "has_connection", "(", "i", ",", "j", ")", "==", "True", ")", ":", "axes", ".", "plot", "(", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "0", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "1", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "2", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "2", "]", "]", ",", "'b-'", ",", "linewidth", "=", "0.5", ")", "else", ":", "for", "j", "in", "self", ".", "get_neighbors", "(", "i", ")", ":", "if", "(", "(", "self", ".", "has_connection", "(", "i", ",", "j", ")", "==", "True", ")", "and", "(", "i", ">", "j", ")", ")", ":", "# draw connection between two points only one time\r", "axes", ".", "plot", "(", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "0", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "0", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "1", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "1", "]", "]", ",", "[", "self", ".", "_osc_loc", "[", "i", "]", "[", "2", "]", ",", "self", ".", "_osc_loc", "[", "j", "]", "[", "2", "]", "]", ",", "'b-'", ",", "linewidth", "=", "0.5", ")", "plt", ".", "grid", "(", ")", "plt", ".", "show", "(", ")" ]

[ "!" ]

[ "def", "getAllConnectedInterface", "(", ")", ":", "all_devices", "=", "hid", ".", "find_all_hid_devices", "(", ")", "# find devices with good vid/pid", "all_mbed_devices", "=", "[", "]", "for", "d", "in", "all_devices", ":", "if", "(", "d", ".", "product_name", ".", "find", "(", "\"MicArray\"", ")", ">=", "0", ")", ":", "all_mbed_devices", ".", "append", "(", "d", ")", "boards", "=", "[", "]", "for", "dev", "in", "all_mbed_devices", ":", "try", ":", "dev", ".", "open", "(", "shared", "=", "False", ")", "report", "=", "dev", ".", "find_output_reports", "(", ")", "if", "(", "len", "(", "report", ")", "==", "1", ")", ":", "new_board", "=", "PyWinUSB", "(", ")", "new_board", ".", "report", "=", "report", "[", "0", "]", "new_board", ".", "vendor_name", "=", "dev", ".", "vendor_name", "new_board", ".", "product_name", "=", "dev", ".", "product_name", "new_board", ".", "serial_number", "=", "dev", ".", "serial_number", "new_board", ".", "vid", "=", "dev", ".", "vendor_id", "new_board", ".", "pid", "=", "dev", ".", "product_id", "new_board", ".", "device", "=", "dev", "new_board", ".", "device", ".", "set_raw_data_handler", "(", "new_board", ".", "rx_handler", ")", "boards", ".", "append", "(", "new_board", ")", "except", "Exception", "as", "e", ":", "logging", ".", "error", "(", "\"Receiving Exception: %s\"", ",", "e", ")", "dev", ".", "close", "(", ")", "return", "boards" ]

[ "returns", "all", "the", "connected", "CMSIS", "-", "DAP", "devices" ]

[ "def", "copy", "(", "self", ")", ":", "vs", "=", "ValueSet", "(", "bits", "=", "self", ".", "bits", ")", "vs", ".", "_regions", "=", "self", ".", "_regions", ".", "copy", "(", ")", "vs", ".", "_region_base_addrs", "=", "self", ".", "_region_base_addrs", ".", "copy", "(", ")", "vs", ".", "_reversed", "=", "self", ".", "_reversed", "vs", ".", "_si", "=", "self", ".", "_si", ".", "copy", "(", ")", "return", "vs" ]

[ "Make", "a", "copy", "of", "self", "and", "return", "." ]

[ "def", "close_authenticator", "(", "self", ")", ":", "_logger", ".", "info", "(", "\"Shutting down CBS session on connection: %r.\"", ",", "self", ".", "_connection", ".", "container_id", ")", "try", ":", "_logger", ".", "debug", "(", "\"Unlocked CBS to close on connection: %r.\"", ",", "self", ".", "_connection", ".", "container_id", ")", "self", ".", "_cbs_auth", ".", "destroy", "(", ")", "_logger", ".", "info", "(", "\"Auth closed, destroying session on connection: %r.\"", ",", "self", ".", "_connection", ".", "container_id", ")", "self", ".", "_session", ".", "destroy", "(", ")", "finally", ":", "_logger", ".", "info", "(", "\"Finished shutting down CBS session on connection: %r.\"", ",", "self", ".", "_connection", ".", "container_id", ")" ]

[ "Close", "the", "CBS", "auth", "channel", "and", "session", "." ]

[ "def", "get_lines", "(", "self", ",", "key", ")", ":", "if", "key", "in", "self", ".", "_indices", ":", "return", "self", ".", "_indices", "[", "key", "]", ".", "values", "(", ")", "else", ":", "return", "[", "]" ]

[ "Return", "header", "lines", "having", "the", "given", "key", "as", "their", "type" ]

[ "def", "charts_get", "(", "self", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'callback'", ")", ":", "return", "self", ".", "charts_get_with_http_info", "(", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "charts_get_with_http_info", "(", "*", "*", "kwargs", ")", "return", "data" ]

[ "Charts", "Returns", "a", "list", "of", "Charts", "ordered", "by", "creation", "date", "(", "newest", "first", ")", ".", "A", "Chart", "is", "chosen", "by", "Pollster", "editors", ".", "One", "example", "is", "\\", "Obama", "job", "approval", "-", "Democrats", "\\", ".", "It", "is", "always", "based", "upon", "a", "single", "Question", ".", "Users", "should", "strongly", "consider", "basing", "their", "analysis", "on", "Questions", "instead", ".", "Charts", "are", "derived", "data", ";", "Pollster", "editors", "publish", "them", "and", "change", "them", "as", "editorial", "priorities", "change", "." ]

[ "def", "share_secret", "(", "threshold", ",", "nshares", ",", "secret", ",", "identifier", ",", "hash_id", "=", "Hash", ".", "SHA256", ")", ":", "if", "identifier", "is", "None", ":", "raise", "TSSError", "(", "'an identifier must be provided'", ")", "if", "not", "Hash", ".", "is_valid", "(", "hash_id", ")", ":", "raise", "TSSError", "(", "'invalid hash algorithm %s'", "%", "hash_id", ")", "secret", "=", "encode", "(", "secret", ")", "identifier", "=", "encode", "(", "identifier", ")", "if", "hash_id", "!=", "Hash", ".", "NONE", ":", "secret", "+=", "Hash", ".", "to_func", "(", "hash_id", ")", "(", "secret", ")", ".", "digest", "(", ")", "shares", "=", "generate_shares", "(", "threshold", ",", "nshares", ",", "secret", ")", "header", "=", "format_header", "(", "identifier", ",", "hash_id", ",", "threshold", ",", "len", "(", "secret", ")", "+", "1", ")", "return", "[", "format_share", "(", "header", ",", "share", ")", "for", "share", "in", "shares", "]" ]

[ "Create", "nshares", "of", "the", "secret", ".", "threshold", "specifies", "the", "number", "of", "shares", "needed", "for", "reconstructing", "the", "secret", "value", ".", "A", "0", "-", "16", "bytes", "identifier", "must", "be", "provided", ".", "Optionally", "the", "secret", "is", "hashed", "with", "the", "algorithm", "specified", "by", "hash_id", "a", "class", "attribute", "of", "Hash", ".", "This", "function", "must", "return", "a", "list", "of", "formatted", "shares", "or", "raises", "a", "TSSError", "exception", "if", "anything", "went", "wrong", "." ]

[ "def", "get_service_references", "(", "self", ",", "clazz", ",", "ldap_filter", "=", "None", ")", ":", "# type: (Optional[str], Optional[str]) -> Optional[List[ServiceReference]]", "refs", "=", "self", ".", "__framework", ".", "find_service_references", "(", "clazz", ",", "ldap_filter", ")", "if", "refs", ":", "for", "ref", "in", "refs", ":", "if", "ref", ".", "get_bundle", "(", ")", "is", "not", "self", ".", "__bundle", ":", "refs", ".", "remove", "(", "ref", ")", "return", "refs" ]

[ "Returns", "the", "service", "references", "for", "services", "that", "were", "registered", "under", "the", "specified", "class", "by", "this", "bundle", "and", "matching", "the", "given", "filter" ]

[ "def", "difference", "(", "self", ",", "*", "other", ")", ":", "from_frozenset", "=", "self", ".", "items", ".", "difference", "(", "*", "map", "(", "set", ",", "other", ")", ")", "return", "self", ".", "from_iterable", "(", "from_frozenset", ",", "sort", "=", "True", ")" ]

[ "Returns", "a", "new", ":", "class", ":", "FrameSet", "with", "elements", "in", "self", "but", "not", "in", "other", "." ]

[ "def", "save_qasm", "(", "self", ",", "file_path", ":", "Union", "[", "str", ",", "bytes", ",", "int", "]", ",", "header", ":", "Optional", "[", "str", "]", "=", "None", ",", "precision", ":", "int", "=", "10", ",", "qubit_order", ":", "ops", ".", "QubitOrderOrList", "=", "ops", ".", "QubitOrder", ".", "DEFAULT", ",", ")", "->", "None", ":", "self", ".", "_to_qasm_output", "(", "header", ",", "precision", ",", "qubit_order", ")", ".", "save", "(", "file_path", ")" ]

[ "Save", "a", "QASM", "file", "equivalent", "to", "the", "circuit", "." ]

[ "def", "put", "(", "self", ",", "path", ",", "data", ",", "*", "*", "kwargs", ")", ":", "url", "=", "self", ".", "_make_url", "(", "path", ")", "return", "self", ".", "_make_request", "(", "\"PUT\"", ",", "url", ",", "data", "=", "data", ",", "*", "*", "kwargs", ")" ]

[ "Perform", "an", "HTTP", "PUT", "request", "of", "the", "specified", "path", "in", "Device", "Cloud" ]

[ "def", "getOriginTrackedDeviceInfo", "(", "self", ",", "origin", ",", "unOriginInfoSize", ")", ":", "fn", "=", "self", ".", "function_table", ".", "getOriginTrackedDeviceInfo", "pOriginInfo", "=", "InputOriginInfo_t", "(", ")", "result", "=", "fn", "(", "origin", ",", "byref", "(", "pOriginInfo", ")", ",", "unOriginInfoSize", ")", "return", "result", ",", "pOriginInfo" ]

[ "Retrieves", "useful", "information", "for", "the", "origin", "of", "this", "action" ]

[ "def", "tn_mean", "(", "tasmin", ",", "freq", "=", "'YS'", ")", ":", "arr", "=", "tasmin", ".", "resample", "(", "time", "=", "freq", ")", "if", "freq", "else", "tasmin", "return", "arr", ".", "mean", "(", "dim", "=", "'time'", ",", "keep_attrs", "=", "True", ")" ]

[ "r", "Mean", "minimum", "temperature", "." ]

[ "def", "H9", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_H9'", ")", ":", "self", ".", "_H9", "=", "-", "(", "self", ".", "P", "*", "np", ".", "log", "(", "self", ".", "P", "+", "self", ".", "eps", ")", ")", ".", "sum", "(", "2", ")", ".", "sum", "(", "1", ")", "return", "self", ".", "_H9" ]

[ "Entropy", "." ]

[ "def", "_result_object", "(", "result", ")", ":", "content_type", "=", "result", ".", "headers", ".", "get", "(", "'content-type'", ",", "None", ")", "if", "content_type", "is", "None", "or", "content_type", ".", "startswith", "(", "'application/json'", ")", ":", "# This function is only called when there is content expected.", "# Therefore, a response without content will result in a ParseError.", "try", ":", "return", "result", ".", "json", "(", "object_pairs_hook", "=", "OrderedDict", ")", "except", "ValueError", "as", "exc", ":", "raise", "ParseError", "(", "\"JSON parse error in HTTP response: {}. \"", "\"HTTP request: {} {}. \"", "\"Response status {}. \"", "\"Response content-type: {!r}. \"", "\"Content (max.1000, decoded using {}): {}\"", ".", "format", "(", "exc", ".", "args", "[", "0", "]", ",", "result", ".", "request", ".", "method", ",", "result", ".", "request", ".", "url", ",", "result", ".", "status_code", ",", "content_type", ",", "result", ".", "encoding", ",", "_text_repr", "(", "result", ".", "text", ",", "1000", ")", ")", ")", "elif", "content_type", ".", "startswith", "(", "'text/html'", ")", ":", "# We are in some error situation. The HMC returns HTML content", "# for some 5xx status codes. We try to deal with it somehow,", "# but we are not going as far as real HTML parsing.", "m", "=", "re", ".", "search", "(", "r'charset=([^;,]+)'", ",", "content_type", ")", "if", "m", ":", "encoding", "=", "m", ".", "group", "(", "1", ")", "# e.g. RFC \"ISO-8859-1\"", "else", ":", "encoding", "=", "'utf-8'", "try", ":", "html_uni", "=", "result", ".", "content", ".", "decode", "(", "encoding", ")", "except", "LookupError", ":", "html_uni", "=", "result", ".", "content", ".", "decode", "(", ")", "# We convert to one line to be regexp-friendly.", "html_oneline", "=", "html_uni", ".", "replace", "(", "'\\r\\n'", ",", "'\\\\n'", ")", ".", "replace", "(", "'\\r'", ",", "'\\\\n'", ")", ".", "replace", "(", "'\\n'", ",", "'\\\\n'", ")", "# Check for some well-known errors:", "if", "re", ".", "search", "(", "r'javax\\.servlet\\.ServletException: '", "r'Web Services are not enabled\\.'", ",", "html_oneline", ")", ":", "html_title", "=", "\"Console Configuration Error\"", "html_details", "=", "\"Web Services API is not enabled on the HMC.\"", "html_reason", "=", "HTML_REASON_WEB_SERVICES_DISABLED", "else", ":", "m", "=", "re", ".", "search", "(", "r'<title>([^<]*)</title>.*'", "r'<h2>Details:</h2>(.*)(<hr size=\"1\" noshade>)?</body>'", ",", "html_oneline", ")", "if", "m", ":", "html_title", "=", "m", ".", "group", "(", "1", ")", "# Spend a reasonable effort to make the HTML readable:", "html_details", "=", "m", ".", "group", "(", "2", ")", ".", "replace", "(", "'<p>'", ",", "'\\\\n'", ")", ".", "replace", "(", "'<br>'", ",", "'\\\\n'", ")", ".", "replace", "(", "'\\\\n\\\\n'", ",", "'\\\\n'", ")", ".", "strip", "(", ")", "else", ":", "html_title", "=", "\"Console Internal Error\"", "html_details", "=", "\"Response body: {!r}\"", ".", "format", "(", "html_uni", ")", "html_reason", "=", "HTML_REASON_OTHER", "message", "=", "\"{}: {}\"", ".", "format", "(", "html_title", ",", "html_details", ")", "# We create a minimal JSON error object (to the extent we use it", "# when processing it):", "result_obj", "=", "{", "'http-status'", ":", "result", ".", "status_code", ",", "'reason'", ":", "html_reason", ",", "'message'", ":", "message", ",", "'request-uri'", ":", "result", ".", "request", ".", "url", ",", "'request-method'", ":", "result", ".", "request", ".", "method", ",", "}", "return", "result_obj", "elif", "content_type", ".", "startswith", "(", "'application/vnd.ibm-z-zmanager-metrics'", ")", ":", "content_bytes", "=", "result", ".", "content", "assert", "isinstance", "(", "content_bytes", ",", "six", ".", "binary_type", ")", "return", "content_bytes", ".", "decode", "(", "'utf-8'", ")", "# as a unicode object", "else", ":", "raise", "ParseError", "(", "\"Unknown content type in HTTP response: {}. \"", "\"HTTP request: {} {}. \"", "\"Response status {}. \"", "\"Response content-type: {!r}. \"", "\"Content (max.1000, decoded using {}): {}\"", ".", "format", "(", "content_type", ",", "result", ".", "request", ".", "method", ",", "result", ".", "request", ".", "url", ",", "result", ".", "status_code", ",", "content_type", ",", "result", ".", "encoding", ",", "_text_repr", "(", "result", ".", "text", ",", "1000", ")", ")", ")" ]

[ "Return", "the", "JSON", "payload", "in", "the", "HTTP", "response", "as", "a", "Python", "dict", "." ]

[ "def", "logout", "(", "self", ")", ":", "if", "self", ".", "logged_on", ":", "self", ".", "logged_on", "=", "False", "self", ".", "send", "(", "MsgProto", "(", "EMsg", ".", "ClientLogOff", ")", ")", "try", ":", "self", ".", "wait_event", "(", "self", ".", "EVENT_DISCONNECTED", ",", "timeout", "=", "5", ",", "raises", "=", "True", ")", "except", ":", "self", ".", "disconnect", "(", ")", "self", ".", "idle", "(", ")" ]

[ "Logout", "from", "steam", ".", "Doesn", "t", "nothing", "if", "not", "logged", "on", "." ]

[ "def", "turbulent_Sieder_Tate", "(", "Re", ",", "Pr", ",", "mu", "=", "None", ",", "mu_w", "=", "None", ")", ":", "Nu", "=", "0.027", "*", "Re", "**", "0.8", "*", "Pr", "**", "(", "1", "/", "3.", ")", "if", "mu_w", "and", "mu", ":", "Nu", "*=", "(", "mu", "/", "mu_w", ")", "**", "0.14", "return", "Nu" ]

[ "r", "Calculates", "internal", "convection", "Nusselt", "number", "for", "turbulent", "flows", "in", "pipe", "according", "to", "[", "1", "]", "_", "and", "supposedly", "[", "2", "]", "_", "." ]

[ "def", "rect", "(", "self", ")", ":", "CheckParent", "(", "self", ")", "val", "=", "_fitz", ".", "Annot_rect", "(", "self", ")", "val", "=", "Rect", "(", "val", ")", "return", "val" ]

[ "Rectangle", "containing", "the", "annot" ]

[ "def", "update_port_postcommit", "(", "self", ",", "context", ")", ":", "port", "=", "context", ".", "current", "orig_port", "=", "context", ".", "original", "network", "=", "context", ".", "network", ".", "current", "log_context", "(", "\"update_port_postcommit: port\"", ",", "port", ")", "log_context", "(", "\"update_port_postcommit: orig\"", ",", "orig_port", ")", "tenant_id", "=", "port", "[", "'project_id'", "]", "# Device id can change without a port going DOWN, but the new device", "# id may not be supported", "if", "orig_port", "and", "port", "[", "'device_id'", "]", "!=", "orig_port", "[", "'device_id'", "]", ":", "self", ".", "_delete_port_resources", "(", "orig_port", ",", "context", ".", "original_host", ")", "if", "context", ".", "status", "==", "n_const", ".", "PORT_STATUS_DOWN", ":", "if", "(", "context", ".", "original_host", "and", "context", ".", "status", "!=", "context", ".", "original_status", ")", ":", "self", ".", "_delete_port_resources", "(", "orig_port", ",", "context", ".", "original_host", ")", "self", ".", "_try_to_release_dynamic_segment", "(", "context", ",", "migration", "=", "True", ")", "else", ":", "self", ".", "create_tenant", "(", "tenant_id", ")", "self", ".", "create_network", "(", "network", ")", "if", "context", ".", "binding_levels", ":", "segments", "=", "[", "level", "[", "'bound_segment'", "]", "for", "level", "in", "context", ".", "binding_levels", "]", "self", ".", "create_segments", "(", "segments", ")", "self", ".", "create_instance", "(", "port", ")", "self", ".", "create_port", "(", "port", ")", "self", ".", "create_port_binding", "(", "port", ",", "context", ".", "host", ")" ]

[ "Send", "port", "updates", "to", "CVX" ]

[ "def", "child_", "(", "self", ",", "ctx", ")", ":", "if", "self", ".", "frontPageItem", ".", "defaultApplication", "is", "None", ":", "return", "self", ".", "webViewer", ".", "wrapModel", "(", "_OfferingsFragment", "(", "self", ".", "frontPageItem", ")", ")", "else", ":", "return", "SharingIndex", "(", "self", ".", "frontPageItem", ".", "defaultApplication", ".", "open", "(", ")", ",", "self", ".", "webViewer", ")", ".", "locateChild", "(", "ctx", ",", "[", "''", "]", ")", "[", "0", "]" ]

[ "If", "the", "root", "resource", "is", "requested", "return", "the", "primary", "application", "s", "front", "page", "if", "a", "primary", "application", "has", "been", "chosen", ".", "Otherwise", "return", "self", "since", "this", "page", "can", "render", "a", "simple", "index", "." ]

[ "def", "setup", "(", ")", ":", "name", "=", "\"Poisson\"", "link", "=", "np", ".", "exp", "scale", "=", "False", "shape", "=", "False", "skewness", "=", "False", "mean_transform", "=", "np", ".", "log", "cythonized", "=", "True", "return", "name", ",", "link", ",", "scale", ",", "shape", ",", "skewness", ",", "mean_transform", ",", "cythonized" ]

[ "Returns", "the", "attributes", "of", "this", "family" ]

[ "def", "process", "(", "self", ",", "input_symbol", ")", ":", "self", ".", "input_symbol", "=", "input_symbol", "(", "self", ".", "action", ",", "self", ".", "next_state", ")", "=", "self", ".", "get_transition", "(", "self", ".", "input_symbol", ",", "self", ".", "current_state", ")", "if", "self", ".", "action", "is", "not", "None", ":", "self", ".", "action", "(", "self", ")", "self", ".", "current_state", "=", "self", ".", "next_state", "self", ".", "next_state", "=", "None" ]

[ "This", "is", "the", "main", "method", "that", "you", "call", "to", "process", "input", ".", "This", "may", "cause", "the", "FSM", "to", "change", "state", "and", "call", "an", "action", ".", "This", "method", "calls", "get_transition", "()", "to", "find", "the", "action", "and", "next_state", "associated", "with", "the", "input_symbol", "and", "current_state", ".", "If", "the", "action", "is", "None", "then", "the", "action", "is", "not", "called", "and", "only", "the", "current", "state", "is", "changed", ".", "This", "method", "processes", "one", "complete", "input", "symbol", ".", "You", "can", "process", "a", "list", "of", "symbols", "(", "or", "a", "string", ")", "by", "calling", "process_list", "()", "." ]

[ "def", "pprint", "(", "obj", ",", "file_", "=", "None", ")", ":", "if", "file_", "is", "None", ":", "file_", "=", "sys", ".", "stdout", "# functions, methods", "if", "callable", "(", "obj", ")", "and", "hasattr", "(", "obj", ",", "\"_code\"", ")", ":", "obj", ".", "_code", ".", "pprint", "(", "file_", ")", "return", "# classes", "if", "isinstance", "(", "obj", ",", "type", ")", "and", "hasattr", "(", "obj", ",", "\"_constructors\"", ")", ":", "constructors", "=", "obj", ".", "_constructors", "for", "names", ",", "func", "in", "sorted", "(", "constructors", ".", "items", "(", ")", ")", ":", "func", ".", "_code", ".", "pprint", "(", "file_", ")", "return", "raise", "TypeError", "(", "\"unkown type\"", ")" ]

[ "Prints", "debug", "information", "for", "various", "public", "objects", "like", "methods", "functions", "constructors", "etc", "." ]

[ "def", "update_dict", "(", "input_dict", ",", "key", ",", "value", ")", ":", "if", "key", "in", "input_dict", ":", "input_dict", "[", "key", "]", ".", "append", "(", "value", ")", "else", ":", "input_dict", "[", "key", "]", "=", "[", "value", "]", "return", "input_dict" ]

[ "update_dict", "will", "update", "lists", "in", "a", "dictionary", ".", "If", "the", "key", "is", "not", "included", "if", "will", "add", "as", "new", "list", ".", "If", "it", "is", "it", "will", "append", ".", ":", "param", "input_dict", ":", "the", "dict", "to", "update", ":", "param", "value", ":", "the", "value", "to", "update", "with" ]

[ "def", "iter_dialogs", "(", "self", ",", "limit", "=", "None", ",", "*", ",", "offset_date", "=", "None", ",", "offset_id", "=", "0", ",", "offset_peer", "=", "types", ".", "InputPeerEmpty", "(", ")", ",", "ignore_migrated", "=", "False", ")", ":", "return", "_DialogsIter", "(", "self", ",", "limit", ",", "offset_date", "=", "offset_date", ",", "offset_id", "=", "offset_id", ",", "offset_peer", "=", "offset_peer", ",", "ignore_migrated", "=", "ignore_migrated", ")" ]

[ "Returns", "an", "iterator", "over", "the", "dialogs", "yielding", "limit", "at", "most", ".", "Dialogs", "are", "the", "open", "chats", "or", "conversations", "with", "other", "people", "groups", "you", "have", "joined", "or", "channels", "you", "are", "subscribed", "to", "." ]

[ "def", "readers", "(", "self", ")", ":", "return", "list", "(", "(", "fd", ",", "data", ")", "for", "fd", ",", "(", "data", ",", "gen", ")", "in", "self", ".", "_rfds", ".", "items", "(", ")", ")" ]

[ "Return", "a", "list", "of", "(", "fd", "data", ")", "tuples", "for", "every", "FD", "registered", "for", "receive", "readiness", "." ]

[ "def", "read", "(", "self", ",", "timeout", "=", "None", ")", ":", "# NOTE: copying over this comment from Connection, because there is", "# knowledge captured here, even if the details are stale", "# Because of the timer callback to dataRead when we re-buffered,", "# there's a chance that in between we've lost the socket. If that's", "# the case, just silently return as some code elsewhere would have", "# already notified us. That bug could be fixed by improving the", "# message reading so that we consume all possible messages and ensure", "# that only a partial message was rebuffered, so that we can rely on", "# the next read event to read the subsequent message.", "if", "not", "hasattr", "(", "self", ",", "'_sock'", ")", ":", "return", "None", "# This is sort of a hack because we're faking that data is ready, but", "# it works for purposes of supporting timeouts", "if", "timeout", ":", "if", "self", ".", "_heartbeat_timeout", ":", "self", ".", "_heartbeat_timeout", ".", "delete", "(", ")", "self", ".", "_heartbeat_timeout", "=", "event", ".", "timeout", "(", "timeout", ",", "self", ".", "_sock_read_cb", ",", "self", ".", "_sock", ")", "elif", "self", ".", "_heartbeat_timeout", ":", "self", ".", "_heartbeat_timeout", ".", "delete", "(", ")", "self", ".", "_heartbeat_timeout", "=", "None", "return", "self", ".", "_sock", ".", "read", "(", ")" ]

[ "Read", "from", "the", "transport", ".", "If", "no", "data", "is", "available", "should", "return", "None", ".", "The", "timeout", "is", "ignored", "as", "this", "returns", "only", "data", "that", "has", "already", "been", "buffered", "locally", "." ]

[ "def", "map", "(", "self", ",", "func", ")", ":", "return", "TList", "(", "[", "func", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "items", "(", ")", "]", ")" ]

[ ":", "param", "func", ":", ":", "type", "func", ":", "(", "K", "T", ")", "-", ">", "U", ":", "rtype", ":", "TList", "[", "U", "]" ]

[ "def", "next", "(", "self", ")", ":", "if", "not", "self", ".", "__has_more", "(", ")", ":", "raise", "StopIteration", "(", ")", "else", ":", "return", "javabridge", ".", "get_env", "(", ")", ".", "get_string", "(", "self", ".", "__next", "(", ")", ")" ]

[ "Reads", "the", "next", "dataset", "row", "." ]

[ "def", "archive_experiment", "(", "experiment", ")", ":", "redis", "=", "oz", ".", "redis", ".", "create_connection", "(", ")", "oz", ".", "bandit", ".", "Experiment", "(", "redis", ",", "experiment", ")", ".", "archive", "(", ")" ]

[ "Archives", "an", "experiment" ]

[ "def", "init", "(", "self", ",", "n", "=", "0", ",", "ftype", "=", "\"real\"", ",", "colfac", "=", "1.0e-8", ",", "lmfac", "=", "1.0e-3", ",", "fid", "=", "0", ")", ":", "ftype", "=", "self", ".", "_gettype", "(", "ftype", ")", "self", ".", "_fitids", "[", "fid", "]", "[", "\"stat\"", "]", "=", "False", "self", ".", "_fitids", "[", "fid", "]", "[", "\"solved\"", "]", "=", "False", "self", ".", "_fitids", "[", "fid", "]", "[", "\"haserr\"", "]", "=", "False", "self", ".", "_fitids", "[", "fid", "]", "[", "\"fit\"", "]", "=", "False", "self", ".", "_fitids", "[", "fid", "]", "[", "\"looped\"", "]", "=", "False", "if", "self", ".", "_fitproxy", ".", "init", "(", "fid", ",", "n", ",", "ftype", ",", "colfac", ",", "lmfac", ")", ":", "self", ".", "_fitids", "[", "fid", "]", "[", "\"stat\"", "]", "=", "self", ".", "_getstate", "(", "fid", ")", "else", ":", "return", "False" ]

[ "Set", "selected", "properties", "of", "the", "fitserver", "instance", "." ]

[ "def", "find_referenced_subfiles", "(", "self", ",", "directory", ")", ":", "if", "directory", "is", "None", ":", "return", "[", "]", "pattern", "=", "r'''[\\'\\\"]?(%s%s[^\\s\\'\\\"]+)[\\'\\\"]?'''", "%", "(", "escape", "(", "directory", ")", ",", "escape", "(", "sep", ")", ")", "return", "self", ".", "find_pattern_references", "(", "pattern", ")" ]

[ "Return", "list", "of", "files", "below", "specified", "directory", "in", "job", "inputs", ".", "Could", "use", "more", "sophisticated", "logic", "(", "match", "quotes", "to", "handle", "spaces", "handle", "subdirectories", "etc", "...", ")", "." ]

[ "def", "inverse_transform_fn", "(", "bijector", ")", ":", "if", "not", "mcmc_util", ".", "is_list_like", "(", "bijector", ")", ":", "bijector", "=", "[", "bijector", "]", "def", "fn", "(", "state_parts", ")", ":", "return", "[", "b", ".", "inverse", "(", "sp", ")", "for", "b", ",", "sp", "in", "zip", "(", "bijector", ",", "state_parts", ")", "]", "return", "fn" ]

[ "Makes", "a", "function", "which", "applies", "a", "list", "of", "Bijectors", "inverse", "s", "." ]

[ "def", "extract", "(", "self", ",", "html_contents", ",", "css_contents", "=", "None", ",", "base_url", "=", "None", ")", ":", "# Clean HTML", "html_extractor", "=", "self", ".", "html_extractor", "(", "html_contents", ",", "self", ".", "_xpaths_to_keep", ",", "self", ".", "_xpaths_to_discard", ")", "has_matches", "=", "html_extractor", ".", "parse", "(", ")", "if", "has_matches", ":", "# Relative to absolute URLs", "if", "base_url", "is", "not", "None", ":", "html_extractor", ".", "rel_to_abs", "(", "base_url", ")", "# Convert ElementTree to string", "cleaned_html", "=", "html_extractor", ".", "to_string", "(", ")", "else", ":", "cleaned_html", "=", "None", "# Clean CSS", "if", "css_contents", "is", "not", "None", ":", "if", "cleaned_html", "is", "not", "None", ":", "css_extractor", "=", "self", ".", "css_extractor", "(", "css_contents", ",", "cleaned_html", ")", "css_extractor", ".", "parse", "(", ")", "# Relative to absolute URLs", "if", "base_url", "is", "not", "None", ":", "css_extractor", ".", "rel_to_abs", "(", "base_url", ")", "cleaned_css", "=", "css_extractor", ".", "to_string", "(", ")", "else", ":", "cleaned_css", "=", "None", "else", ":", "return", "cleaned_html", "return", "(", "cleaned_html", ",", "cleaned_css", ")" ]

[ "Extracts", "the", "cleaned", "html", "tree", "as", "a", "string", "and", "only", "css", "rules", "matching", "the", "cleaned", "html", "tree" ]

[ "def", "validate", "(", "self", ",", "uri", ")", ":", "if", "WURIComponentVerifier", ".", "validate", "(", "self", ",", "uri", ")", "is", "False", ":", "return", "False", "try", ":", "WStrictURIQuery", "(", "WURIQuery", ".", "parse", "(", "uri", ".", "component", "(", "self", ".", "component", "(", ")", ")", ")", ",", "*", "self", ".", "__specs", ",", "extra_parameters", "=", "self", ".", "__extra_parameters", ")", "except", "ValueError", ":", "return", "False", "return", "True" ]

[ "Check", "that", "an", "query", "part", "of", "an", "URI", "is", "compatible", "with", "this", "descriptor", ".", "Return", "True", "if", "the", "URI", "is", "compatible", "." ]

[ "def", "boolean", "(", "text", ")", ":", "tmp", "=", "text", ".", "lower", "(", ")", "if", "tmp", ".", "isdigit", "(", ")", ":", "return", "bool", "(", "int", "(", "tmp", ")", ")", "elif", "tmp", "in", "(", "'t'", ",", "'true'", ",", "'on'", ",", "'yes'", ")", ":", "return", "True", "elif", "tmp", "in", "(", "'f'", ",", "'false'", ",", "'off'", ",", "'no'", ")", ":", "return", "False", "raise", "ValueError", "(", "\"invalid Boolean value %r\"", "%", "text", ")" ]

[ "An", "alternative", "to", "the", "bool", "argument", "type", "which", "interprets", "string", "values", "." ]

[ "def", "parallel_map", "(", "client", ",", "task", ",", "args", ",", "message", ",", "batchsize", "=", "1", ",", "background", "=", "False", ",", "nargs", "=", "None", ")", ":", "show_progress", "=", "bool", "(", "message", ")", "njobs", "=", "get_njobs", "(", "nargs", ",", "args", ")", "nproc", "=", "len", "(", "client", ")", "logger", ".", "debug", "(", "'parallel_map: len(client) = {}'", ".", "format", "(", "len", "(", "client", ")", ")", ")", "view", "=", "client", ".", "load_balanced_view", "(", ")", "if", "show_progress", ":", "message", "+=", "' (IP:{}w:{}b)'", ".", "format", "(", "nproc", ",", "batchsize", ")", "pbar", "=", "setup_progressbar", "(", "message", ",", "njobs", ",", "simple_progress", "=", "True", ")", "if", "not", "background", ":", "pbar", ".", "start", "(", ")", "map_result", "=", "view", ".", "map", "(", "task", ",", "*", "list", "(", "zip", "(", "*", "args", ")", ")", ",", "chunksize", "=", "batchsize", ")", "if", "background", ":", "return", "map_result", ",", "client", "while", "not", "map_result", ".", "ready", "(", ")", ":", "map_result", ".", "wait", "(", "1", ")", "if", "show_progress", ":", "pbar", ".", "update", "(", "min", "(", "njobs", ",", "map_result", ".", "progress", "*", "batchsize", ")", ")", "if", "show_progress", ":", "pbar", ".", "finish", "(", ")", "return", "map_result" ]

[ "Helper", "to", "map", "a", "function", "over", "a", "sequence", "of", "inputs", "in", "parallel", "with", "progress", "meter", ".", ":", "param", "client", ":", "IPython", ".", "parallel", ".", "Client", "instance", ":", "param", "task", ":", "Function", ":", "param", "args", ":", "Must", "be", "a", "list", "of", "tuples", "of", "arguments", "that", "the", "task", "function", "will", "be", "mapped", "onto", ".", "If", "the", "function", "takes", "a", "single", "argument", "it", "still", "must", "be", "a", "1", "-", "tuple", ".", ":", "param", "message", ":", "String", "for", "progress", "bar", ":", "param", "batchsize", ":", "Jobs", "are", "shipped", "in", "batches", "of", "this", "size", ".", "Higher", "numbers", "mean", "less", "network", "traffic", "but", "longer", "execution", "time", "per", "job", ".", ":", "return", ":", "IPython", ".", "parallel", ".", "AsyncMapResult" ]

[ "def", "quantile", "(", "x", ",", "q", ",", "weights", "=", "None", ")", ":", "# Initial check.", "x", "=", "np", ".", "atleast_1d", "(", "x", ")", "q", "=", "np", ".", "atleast_1d", "(", "q", ")", "# Quantile check.", "if", "np", ".", "any", "(", "q", "<", "0.0", ")", "or", "np", ".", "any", "(", "q", ">", "1.0", ")", ":", "raise", "ValueError", "(", "\"Quantiles must be between 0. and 1.\"", ")", "if", "weights", "is", "None", ":", "# If no weights provided, this simply calls `np.percentile`.", "return", "np", ".", "percentile", "(", "x", ",", "list", "(", "100.0", "*", "q", ")", ")", "else", ":", "# If weights are provided, compute the weighted quantiles.", "weights", "=", "np", ".", "atleast_1d", "(", "weights", ")", "if", "len", "(", "x", ")", "!=", "len", "(", "weights", ")", ":", "raise", "ValueError", "(", "\"Dimension mismatch: len(weights) != len(x).\"", ")", "idx", "=", "np", ".", "argsort", "(", "x", ")", "# sort samples", "sw", "=", "weights", "[", "idx", "]", "# sort weights", "cdf", "=", "np", ".", "cumsum", "(", "sw", ")", "[", ":", "-", "1", "]", "# compute CDF", "cdf", "/=", "cdf", "[", "-", "1", "]", "# normalize CDF", "cdf", "=", "np", ".", "append", "(", "0", ",", "cdf", ")", "# ensure proper span", "quantiles", "=", "np", ".", "interp", "(", "q", ",", "cdf", ",", "x", "[", "idx", "]", ")", ".", "tolist", "(", ")", "return", "quantiles" ]

[ "Compute", "(", "weighted", ")", "quantiles", "from", "an", "input", "set", "of", "samples", "." ]

[ "def", "_custom_init_", "(", "self", ",", "model_name", ",", "other_name", "=", "None", ",", "log_interp", "=", "True", ")", ":", "# Get the data directory", "data_dir_path", "=", "get_user_data_path", "(", ")", "# Sanitize the data file", "filename_sanitized", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "join", "(", "data_dir_path", ",", "'%s.h5'", "%", "model_name", ")", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "filename_sanitized", ")", ":", "raise", "MissingDataFile", "(", "\"The data file %s does not exists. Did you use the \"", "\"TemplateFactory?\"", "%", "(", "filename_sanitized", ")", ")", "# Open the template definition and read from it", "self", ".", "_data_file", "=", "filename_sanitized", "with", "HDFStore", "(", "filename_sanitized", ")", "as", "store", ":", "self", ".", "_data_frame", "=", "store", "[", "'data_frame'", "]", "self", ".", "_parameters_grids", "=", "collections", ".", "OrderedDict", "(", ")", "processed_parameters", "=", "0", "for", "key", "in", "store", ".", "keys", "(", ")", ":", "match", "=", "re", ".", "search", "(", "'p_([0-9]+)_(.+)'", ",", "key", ")", "if", "match", "is", "None", ":", "continue", "else", ":", "tokens", "=", "match", ".", "groups", "(", ")", "this_parameter_number", "=", "int", "(", "tokens", "[", "0", "]", ")", "this_parameter_name", "=", "str", "(", "tokens", "[", "1", "]", ")", "assert", "this_parameter_number", "==", "processed_parameters", ",", "\"Parameters out of order!\"", "self", ".", "_parameters_grids", "[", "this_parameter_name", "]", "=", "store", "[", "key", "]", "processed_parameters", "+=", "1", "self", ".", "_energies", "=", "store", "[", "'energies'", "]", "# Now get the metadata", "metadata", "=", "store", ".", "get_storer", "(", "'data_frame'", ")", ".", "attrs", ".", "metadata", "description", "=", "metadata", "[", "'description'", "]", "name", "=", "metadata", "[", "'name'", "]", "self", ".", "_interpolation_degree", "=", "metadata", "[", "'interpolation_degree'", "]", "self", ".", "_spline_smoothing_factor", "=", "metadata", "[", "'spline_smoothing_factor'", "]", "# Make the dictionary of parameters", "function_definition", "=", "collections", ".", "OrderedDict", "(", ")", "function_definition", "[", "'description'", "]", "=", "description", "function_definition", "[", "'latex'", "]", "=", "'n.a.'", "# Now build the parameters according to the content of the parameter grid", "parameters", "=", "collections", ".", "OrderedDict", "(", ")", "parameters", "[", "'K'", "]", "=", "Parameter", "(", "'K'", ",", "1.0", ")", "parameters", "[", "'scale'", "]", "=", "Parameter", "(", "'scale'", ",", "1.0", ")", "for", "parameter_name", "in", "self", ".", "_parameters_grids", ".", "keys", "(", ")", ":", "grid", "=", "self", ".", "_parameters_grids", "[", "parameter_name", "]", "parameters", "[", "parameter_name", "]", "=", "Parameter", "(", "parameter_name", ",", "grid", ".", "median", "(", ")", ",", "min_value", "=", "grid", ".", "min", "(", ")", ",", "max_value", "=", "grid", ".", "max", "(", ")", ")", "if", "other_name", "is", "None", ":", "super", "(", "TemplateModel", ",", "self", ")", ".", "__init__", "(", "name", ",", "function_definition", ",", "parameters", ")", "else", ":", "super", "(", "TemplateModel", ",", "self", ")", ".", "__init__", "(", "other_name", ",", "function_definition", ",", "parameters", ")", "# Finally prepare the interpolators", "self", ".", "_prepare_interpolators", "(", "log_interp", ")" ]

[ "Custom", "initialization", "for", "this", "model", ":", "param", "model_name", ":", "the", "name", "of", "the", "model", "corresponding", "to", "the", "root", "of", "the", ".", "h5", "file", "in", "the", "data", "directory", ":", "param", "other_name", ":", "(", "optional", ")", "the", "name", "to", "be", "used", "as", "name", "of", "the", "model", "when", "used", "in", "astromodels", ".", "If", "None", "(", "default", ")", "use", "the", "same", "name", "as", "model_name", ":", "return", ":", "none" ]

[ "def", "register", "(", "func", "=", "None", ",", "name", "=", "None", ")", ":", "if", "not", "name", ":", "raise", "CompilationError", "(", "'Name is required'", ")", "if", "not", "func", ":", "return", "partial", "(", "register", ",", "name", "=", "name", ")", "return", "FormatRegistry", ".", "register", "(", "name", ",", "func", ")" ]

[ "Expose", "compiler", "to", "factory", "." ]

[ "def", "update_rotation", "(", "self", ",", "dt", ",", "buttons", ")", ":", "assert", "isinstance", "(", "buttons", ",", "dict", ")", "ma", "=", "buttons", "[", "'right'", "]", "-", "buttons", "[", "'left'", "]", "if", "ma", "!=", "0", ":", "self", ".", "stats", "[", "'battery'", "]", "-=", "self", ".", "battery_use", "[", "'angular'", "]", "self", ".", "rotation", "+=", "ma", "*", "dt", "*", "self", ".", "angular_velocity", "# Redirect velocity in new direction", "a", "=", "math", ".", "radians", "(", "self", ".", "rotation", ")", "self", ".", "impulse_dir", "=", "eu", ".", "Vector2", "(", "math", ".", "sin", "(", "a", ")", ",", "math", ".", "cos", "(", "a", ")", ")" ]

[ "Updates", "rotation", "and", "impulse", "direction" ]

[ "def", "ancestry", "(", "self", ",", "context", ")", ":", "log", ".", "debug", "(", "\"get ancestry %s\"", ",", "context", ")", "if", "context", "is", "None", ":", "return", "# Methods include reference to module they are defined in, we", "# don't want that, instead want the module the class is in now", "# (classes are re-ancestored elsewhere).", "if", "hasattr", "(", "context", ",", "'im_class'", ")", ":", "context", "=", "context", ".", "im_class", "elif", "hasattr", "(", "context", ",", "'__self__'", ")", ":", "context", "=", "context", ".", "__self__", ".", "__class__", "if", "hasattr", "(", "context", ",", "'__module__'", ")", ":", "ancestors", "=", "context", ".", "__module__", ".", "split", "(", "'.'", ")", "elif", "hasattr", "(", "context", ",", "'__name__'", ")", ":", "ancestors", "=", "context", ".", "__name__", ".", "split", "(", "'.'", ")", "[", ":", "-", "1", "]", "else", ":", "raise", "TypeError", "(", "\"%s has no ancestors?\"", "%", "context", ")", "while", "ancestors", ":", "log", ".", "debug", "(", "\" %s ancestors %s\"", ",", "context", ",", "ancestors", ")", "yield", "resolve_name", "(", "'.'", ".", "join", "(", "ancestors", ")", ")", "ancestors", ".", "pop", "(", ")" ]

[ "Return", "the", "ancestry", "of", "the", "context", "(", "that", "is", "all", "of", "the", "packages", "and", "modules", "containing", "the", "context", ")", "in", "order", "of", "descent", "with", "the", "outermost", "ancestor", "last", ".", "This", "method", "is", "a", "generator", "." ]

[ "def", "to_kaf", "(", "self", ")", ":", "if", "self", ".", "type", "==", "'NAF'", ":", "for", "node_coref", "in", "self", ".", "__get_corefs_nodes", "(", ")", ":", "node_coref", ".", "set", "(", "'coid'", ",", "node_coref", ".", "get", "(", "'id'", ")", ")", "del", "node_coref", ".", "attrib", "[", "'id'", "]" ]

[ "Converts", "the", "coreference", "layer", "to", "KAF" ]

[ "def", "run", "(", "args", ")", ":", "p", "=", "OptionParser", "(", "run", ".", "__doc__", ")", "p", ".", "set_grid_opts", "(", ")", "p", ".", "set_params", "(", "prog", "=", "\"grid\"", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "==", "0", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "sep", "=", "\":::\"", "if", "sep", "in", "args", ":", "sepidx", "=", "args", ".", "index", "(", "sep", ")", "filenames", "=", "args", "[", "sepidx", "+", "1", ":", "]", "args", "=", "args", "[", ":", "sepidx", "]", "if", "not", "filenames", ":", "filenames", "=", "[", "\"\"", "]", "else", ":", "filenames", "=", "sys", ".", "stdin", "if", "not", "sys", ".", "stdin", ".", "isatty", "(", ")", "else", "[", "\"\"", "]", "cmd", "=", "\" \"", ".", "join", "(", "args", ")", "cmds", "=", "[", "]", "if", "filenames", "else", "[", "(", "cmd", ",", "None", ")", "]", "for", "i", ",", "filename", "in", "enumerate", "(", "filenames", ")", ":", "filename", "=", "filename", ".", "strip", "(", ")", "noextname", "=", "filename", ".", "rsplit", "(", "\".\"", ",", "1", ")", "[", "0", "]", "prefix", ",", "basename", "=", "op", ".", "split", "(", "filename", ")", "basenoextname", "=", "basename", ".", "rsplit", "(", "\".\"", ",", "1", ")", "[", "0", "]", "basefirstname", "=", "basename", ".", "split", "(", "\".\"", ")", "[", "0", "]", "firstname", "=", "op", ".", "join", "(", "prefix", ",", "basefirstname", ")", "ncmd", "=", "cmd", "if", "\"{\"", "in", "ncmd", ":", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{}\"", ",", "filename", ")", "else", ":", "ncmd", "+=", "\" \"", "+", "filename", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{.}\"", ",", "noextname", ")", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{_}\"", ",", "firstname", ")", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{/}\"", ",", "basename", ")", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{/.}\"", ",", "basenoextname", ")", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{/_}\"", ",", "basefirstname", ")", "ncmd", "=", "ncmd", ".", "replace", "(", "\"{#}\"", ",", "str", "(", "i", ")", ")", "outfile", "=", "None", "if", "\">\"", "in", "ncmd", ":", "ncmd", ",", "outfile", "=", "ncmd", ".", "split", "(", "\">\"", ",", "1", ")", "ncmd", ",", "outfile", "=", "ncmd", ".", "strip", "(", ")", ",", "outfile", ".", "strip", "(", ")", "ncmd", "=", "ncmd", ".", "strip", "(", ")", "cmds", ".", "append", "(", "(", "ncmd", ",", "outfile", ")", ")", "for", "ncmd", ",", "outfile", "in", "cmds", ":", "p", "=", "GridProcess", "(", "ncmd", ",", "outfile", "=", "outfile", ",", "extra_opts", "=", "opts", ".", "extra", ",", "grid_opts", "=", "opts", ")", "p", ".", "start", "(", ")" ]

[ "%prog", "run", "command", ":::", "file1", "file2" ]

[ "def", "wind_speed_hub", "(", "self", ",", "weather_df", ")", ":", "if", "self", ".", "power_plant", ".", "hub_height", "in", "weather_df", "[", "'wind_speed'", "]", ":", "wind_speed_hub", "=", "weather_df", "[", "'wind_speed'", "]", "[", "self", ".", "power_plant", ".", "hub_height", "]", "elif", "self", ".", "wind_speed_model", "==", "'logarithmic'", ":", "logging", ".", "debug", "(", "'Calculating wind speed using logarithmic wind '", "'profile.'", ")", "closest_height", "=", "weather_df", "[", "'wind_speed'", "]", ".", "columns", "[", "min", "(", "range", "(", "len", "(", "weather_df", "[", "'wind_speed'", "]", ".", "columns", ")", ")", ",", "key", "=", "lambda", "i", ":", "abs", "(", "weather_df", "[", "'wind_speed'", "]", ".", "columns", "[", "i", "]", "-", "self", ".", "power_plant", ".", "hub_height", ")", ")", "]", "wind_speed_hub", "=", "wind_speed", ".", "logarithmic_profile", "(", "weather_df", "[", "'wind_speed'", "]", "[", "closest_height", "]", ",", "closest_height", ",", "self", ".", "power_plant", ".", "hub_height", ",", "weather_df", "[", "'roughness_length'", "]", ".", "iloc", "[", ":", ",", "0", "]", ",", "self", ".", "obstacle_height", ")", "elif", "self", ".", "wind_speed_model", "==", "'hellman'", ":", "logging", ".", "debug", "(", "'Calculating wind speed using hellman equation.'", ")", "closest_height", "=", "weather_df", "[", "'wind_speed'", "]", ".", "columns", "[", "min", "(", "range", "(", "len", "(", "weather_df", "[", "'wind_speed'", "]", ".", "columns", ")", ")", ",", "key", "=", "lambda", "i", ":", "abs", "(", "weather_df", "[", "'wind_speed'", "]", ".", "columns", "[", "i", "]", "-", "self", ".", "power_plant", ".", "hub_height", ")", ")", "]", "wind_speed_hub", "=", "wind_speed", ".", "hellman", "(", "weather_df", "[", "'wind_speed'", "]", "[", "closest_height", "]", ",", "closest_height", ",", "self", ".", "power_plant", ".", "hub_height", ",", "weather_df", "[", "'roughness_length'", "]", ".", "iloc", "[", ":", ",", "0", "]", ",", "self", ".", "hellman_exp", ")", "elif", "self", ".", "wind_speed_model", "==", "'interpolation_extrapolation'", ":", "logging", ".", "debug", "(", "'Calculating wind speed using linear inter- or '", "'extrapolation.'", ")", "wind_speed_hub", "=", "tools", ".", "linear_interpolation_extrapolation", "(", "weather_df", "[", "'wind_speed'", "]", ",", "self", ".", "power_plant", ".", "hub_height", ")", "elif", "self", ".", "wind_speed_model", "==", "'log_interpolation_extrapolation'", ":", "logging", ".", "debug", "(", "'Calculating wind speed using logarithmic inter- or '", "'extrapolation.'", ")", "wind_speed_hub", "=", "tools", ".", "logarithmic_interpolation_extrapolation", "(", "weather_df", "[", "'wind_speed'", "]", ",", "self", ".", "power_plant", ".", "hub_height", ")", "else", ":", "raise", "ValueError", "(", "\"'{0}' is an invalid value. \"", ".", "format", "(", "self", ".", "wind_speed_model", ")", "+", "\"`wind_speed_model` must be \"", "\"'logarithmic', 'hellman', 'interpolation_extrapolation' \"", "+", "\"or 'log_interpolation_extrapolation'.\"", ")", "return", "wind_speed_hub" ]

[ "r", "Calculates", "the", "wind", "speed", "at", "hub", "height", "." ]

[ "def", "auth_basic", "(", "check", ",", "realm", "=", "\"private\"", ",", "text", "=", "\"Access denied\"", ")", ":", "def", "decorator", "(", "func", ")", ":", "def", "wrapper", "(", "*", "a", ",", "*", "*", "ka", ")", ":", "user", ",", "password", "=", "request", ".", "auth", "or", "(", "None", ",", "None", ")", "if", "user", "is", "None", "or", "not", "check", "(", "user", ",", "password", ")", ":", "response", ".", "headers", "[", "'WWW-Authenticate'", "]", "=", "'Basic realm=\"%s\"'", "%", "realm", "return", "HTTPError", "(", "401", ",", "text", ")", "return", "func", "(", "*", "a", ",", "*", "*", "ka", ")", "return", "wrapper", "return", "decorator" ]

[ "Callback", "decorator", "to", "require", "HTTP", "auth", "(", "basic", ")", ".", "TODO", ":", "Add", "route", "(", "check_auth", "=", "...", ")", "parameter", "." ]

[ "def", "reject_message", "(", "self", ",", "delivery_tag", ",", "requeue", "=", "False", ",", "*", "*", "kwargs", ")", ":", "logger", ".", "info", "(", "'Rejecting message'", ",", "delivery_tag", "=", "delivery_tag", ",", "*", "*", "kwargs", ")", "self", ".", "_channel", ".", "basic_reject", "(", "delivery_tag", ",", "requeue", "=", "requeue", ")" ]

[ "Reject", "the", "message", "delivery", "from", "RabbitMQ", "by", "sending", "a", "Basic", ".", "Reject", "RPC", "method", "for", "the", "delivery", "tag", ".", ":", "param", "int", "delivery_tag", ":", "The", "delivery", "tag", "from", "the", "Basic", ".", "Deliver", "frame" ]

[ "def", "get_group", "(", "value", ")", ":", "group", "=", "Group", "(", ")", "token", ",", "value", "=", "get_display_name", "(", "value", ")", "if", "not", "value", "or", "value", "[", "0", "]", "!=", "':'", ":", "raise", "errors", ".", "HeaderParseError", "(", "\"expected ':' at end of group \"", "\"display name but found '{}'\"", ".", "format", "(", "value", ")", ")", "group", ".", "append", "(", "token", ")", "group", ".", "append", "(", "ValueTerminal", "(", "':'", ",", "'group-display-name-terminator'", ")", ")", "value", "=", "value", "[", "1", ":", "]", "if", "value", "and", "value", "[", "0", "]", "==", "';'", ":", "group", ".", "append", "(", "ValueTerminal", "(", "';'", ",", "'group-terminator'", ")", ")", "return", "group", ",", "value", "[", "1", ":", "]", "token", ",", "value", "=", "get_group_list", "(", "value", ")", "group", ".", "append", "(", "token", ")", "if", "not", "value", ":", "group", ".", "defects", ".", "append", "(", "errors", ".", "InvalidHeaderDefect", "(", "\"end of header in group\"", ")", ")", "if", "value", "[", "0", "]", "!=", "';'", ":", "raise", "errors", ".", "HeaderParseError", "(", "\"expected ';' at end of group but found {}\"", ".", "format", "(", "value", ")", ")", "group", ".", "append", "(", "ValueTerminal", "(", "';'", ",", "'group-terminator'", ")", ")", "value", "=", "value", "[", "1", ":", "]", "if", "value", "and", "value", "[", "0", "]", "in", "CFWS_LEADER", ":", "token", ",", "value", "=", "get_cfws", "(", "value", ")", "group", ".", "append", "(", "token", ")", "return", "group", ",", "value" ]

[ "group", "=", "display", "-", "name", ":", "[", "group", "-", "list", "]", ";", "[", "CFWS", "]" ]

[ "def", "_get_triplet_value_list", "(", "self", ",", "graph", ",", "identity", ",", "rdf_type", ")", ":", "values", "=", "[", "]", "for", "elem", "in", "graph", ".", "objects", "(", "identity", ",", "rdf_type", ")", ":", "values", ".", "append", "(", "elem", ".", "toPython", "(", ")", ")", "return", "values" ]

[ "Get", "a", "list", "of", "values", "from", "RDF", "triples", "when", "more", "than", "one", "may", "be", "present" ]

[ "def", "pack_data", "(", "abi_types", ",", "values", ")", "->", "bytes", ":", "if", "len", "(", "abi_types", ")", "!=", "len", "(", "values", ")", ":", "raise", "ValueError", "(", "\"Length mismatch between provided abi types and values. Got \"", "\"{0} types and {1} values.\"", ".", "format", "(", "len", "(", "abi_types", ")", ",", "len", "(", "values", ")", ")", ",", ")", "normalized_values", "=", "map_abi_data", "(", "[", "abi_address_to_hex", "]", ",", "abi_types", ",", "values", ")", "return", "decode_hex", "(", "''", ".", "join", "(", "remove_0x_prefix", "(", "hex_encode_abi_type", "(", "abi_type", ",", "value", ")", ")", "for", "abi_type", ",", "value", "in", "zip", "(", "abi_types", ",", "normalized_values", ")", ")", ")" ]

[ "Normalize", "data", "and", "pack", "them", "into", "a", "byte", "array" ]

[ "def", "instance", "(", "self", ",", "id", "=", "None", ",", "application", "=", "None", ",", "name", "=", "None", ",", "revision", "=", "None", ",", "environment", "=", "None", ",", "parameters", "=", "None", ",", "submodules", "=", "None", ",", "destroyInterval", "=", "None", ")", ":", "instance", "=", "self", ".", "get_or_create_instance", "(", "id", ",", "application", ",", "revision", ",", "environment", ",", "name", ",", "parameters", ",", "submodules", ",", "destroyInterval", ")", "reconfigure", "=", "False", "# if found:", "# if revision and revision is not found.revision:", "# reconfigure = True", "# if parameters and parameters is not found.parameters:", "# reconfigure = True", "# We need to reconfigure instance", "if", "reconfigure", ":", "instance", ".", "reconfigure", "(", "revision", "=", "revision", ",", "parameters", "=", "parameters", ")", "return", "instance" ]

[ "Smart", "method", ".", "It", "does", "everything", "to", "return", "Instance", "with", "given", "parameters", "within", "the", "application", ".", "If", "instance", "found", "running", "and", "given", "parameters", "are", "actual", ":", "return", "it", ".", "If", "instance", "found", "but", "parameters", "differs", "-", "reconfigure", "instance", "with", "new", "parameters", ".", "If", "instance", "not", "found", ":", "launch", "instance", "with", "given", "parameters", ".", "Return", ":", "Instance", "object", "." ]

[ "def", "is_consistent", "(", "database", ",", "solver", ",", "exchange", "=", "set", "(", ")", ",", "zeromass", "=", "set", "(", ")", ")", ":", "prob", "=", "solver", ".", "create_problem", "(", ")", "compound_set", "=", "_non_localized_compounds", "(", "database", ")", "mass_compounds", "=", "compound_set", ".", "difference", "(", "zeromass", ")", "# Define mass variables", "m", "=", "prob", ".", "namespace", "(", "mass_compounds", ",", "lower", "=", "1", ")", "prob", ".", "set_objective", "(", "m", ".", "sum", "(", "mass_compounds", ")", ")", "# Define constraints", "massbalance_lhs", "=", "{", "reaction", ":", "0", "for", "reaction", "in", "database", ".", "reactions", "}", "for", "(", "compound", ",", "reaction", ")", ",", "value", "in", "iteritems", "(", "database", ".", "matrix", ")", ":", "if", "compound", "not", "in", "zeromass", ":", "mass", "=", "m", "(", "compound", ".", "in_compartment", "(", "None", ")", ")", "massbalance_lhs", "[", "reaction", "]", "+=", "mass", "*", "value", "for", "reaction", ",", "lhs", "in", "iteritems", "(", "massbalance_lhs", ")", ":", "if", "reaction", "not", "in", "exchange", ":", "prob", ".", "add_linear_constraints", "(", "lhs", "==", "0", ")", "result", "=", "prob", ".", "solve_unchecked", "(", "lp", ".", "ObjectiveSense", ".", "Minimize", ")", "return", "result", ".", "success" ]

[ "Try", "to", "assign", "a", "positive", "mass", "to", "each", "compound" ]

[ "def", "round_sig", "(", "x", ",", "sig", ")", ":", "return", "round", "(", "x", ",", "sig", "-", "int", "(", "floor", "(", "log10", "(", "abs", "(", "x", ")", ")", ")", ")", "-", "1", ")" ]

[ "Round", "the", "number", "to", "the", "specified", "number", "of", "significant", "figures" ]

[ "def", "node_filter", "(", "self", ",", "name", ",", "*", "*", "kwargs", ")", ":", "def", "decorator", "(", "func", ")", ":", "self", ".", "filters", "[", "name", "]", "=", "NodeFilter", "(", "name", ",", "func", ",", "*", "*", "kwargs", ")", "return", "decorator" ]

[ "Returns", "a", "decorator", "function", "for", "adding", "a", "node", "filter", "." ]

[ "def", "get_package_id", "(", "self", ",", "name", ")", ":", "json_scheme", "=", "self", ".", "gen_def_json_scheme", "(", "'GetPreConfiguredPackages'", ",", "dict", "(", "HypervisorType", "=", "4", ")", ")", "json_obj", "=", "self", ".", "call_method_post", "(", "method", "=", "'GetPreConfiguredPackages '", ",", "json_scheme", "=", "json_scheme", ")", "for", "package", "in", "json_obj", "[", "'Value'", "]", ":", "packageId", "=", "package", "[", "'PackageID'", "]", "for", "description", "in", "package", "[", "'Descriptions'", "]", ":", "languageID", "=", "description", "[", "'LanguageID'", "]", "packageName", "=", "description", "[", "'Text'", "]", "if", "languageID", "==", "2", "and", "packageName", ".", "lower", "(", ")", "==", "name", ".", "lower", "(", ")", ":", "return", "packageId" ]

[ "Retrieve", "the", "smart", "package", "id", "given", "is", "English", "name" ]

[ "def", "getFileSystemSize", "(", "dirPath", ")", ":", "assert", "os", ".", "path", ".", "exists", "(", "dirPath", ")", "diskStats", "=", "os", ".", "statvfs", "(", "dirPath", ")", "freeSpace", "=", "diskStats", ".", "f_frsize", "*", "diskStats", ".", "f_bavail", "diskSize", "=", "diskStats", ".", "f_frsize", "*", "diskStats", ".", "f_blocks", "return", "freeSpace", ",", "diskSize" ]

[ "Return", "the", "free", "space", "and", "total", "size", "of", "the", "file", "system", "hosting", "dirPath", "." ]

[ "def", "plot", "(", "message", ",", "duration", "=", "1", ",", "ax", "=", "None", ")", ":", "lst_bin", "=", "_encode_binary", "(", "message", ")", "x", ",", "y", "=", "_create_x_y", "(", "lst_bin", ",", "duration", ")", "ax", "=", "_create_ax", "(", "ax", ")", "ax", ".", "plot", "(", "x", ",", "y", ",", "linewidth", "=", "2.0", ")", "delta_y", "=", "0.1", "ax", ".", "set_ylim", "(", "-", "delta_y", ",", "1", "+", "delta_y", ")", "ax", ".", "set_yticks", "(", "[", "0", ",", "1", "]", ")", "delta_x", "=", "0.5", "*", "duration", "ax", ".", "set_xlim", "(", "-", "delta_x", ",", "len", "(", "lst_bin", ")", "*", "duration", "+", "delta_x", ")", "return", "ax" ]

[ "Plot", "a", "message" ]

[ "def", "execute_one_to_many_job", "(", "parent_class", "=", "None", ",", "get_unfinished_kwargs", "=", "None", ",", "get_unfinished_limit", "=", "None", ",", "parser_func", "=", "None", ",", "parser_func_kwargs", "=", "None", ",", "build_url_func_kwargs", "=", "None", ",", "downloader_func", "=", "None", ",", "downloader_func_kwargs", "=", "None", ",", "post_process_response_func", "=", "None", ",", "post_process_response_func_kwargs", "=", "None", ",", "process_item_func_kwargs", "=", "None", ",", "logger", "=", "None", ",", "sleep_time", "=", "None", ")", ":", "# prepare arguments", "get_unfinished_kwargs", "=", "prepare_kwargs", "(", "get_unfinished_kwargs", ")", "parser_func_kwargs", "=", "prepare_kwargs", "(", "parser_func_kwargs", ")", "build_url_func_kwargs", "=", "prepare_kwargs", "(", "build_url_func_kwargs", ")", "downloader_func_kwargs", "=", "prepare_kwargs", "(", "downloader_func_kwargs", ")", "post_process_response_func_kwargs", "=", "prepare_kwargs", "(", "post_process_response_func_kwargs", ")", "process_item_func_kwargs", "=", "prepare_kwargs", "(", "process_item_func_kwargs", ")", "if", "post_process_response_func", "is", "None", ":", "def", "post_process_response_func", "(", "response", ",", "*", "*", "kwargs", ")", ":", "pass", "if", "not", "isinstance", "(", "logger", ",", "SpiderLogger", ")", ":", "raise", "TypeError", "if", "sleep_time", "is", "None", ":", "sleep_time", "=", "0", "# do the real job", "query_set", "=", "parent_class", ".", "get_all_unfinished", "(", "*", "*", "get_unfinished_kwargs", ")", "if", "get_unfinished_limit", "is", "not", "None", ":", "query_set", "=", "query_set", ".", "limit", "(", "get_unfinished_limit", ")", "todo", "=", "list", "(", "query_set", ")", "logger", ".", "log_todo_volumn", "(", "todo", ")", "for", "parent_instance", "in", "todo", ":", "url", "=", "parent_instance", ".", "build_url", "(", "*", "*", "build_url_func_kwargs", ")", "logger", ".", "log_to_crawl_url", "(", "url", ")", "logger", ".", "log_sleeper", "(", "sleep_time", ")", "time", ".", "sleep", "(", "sleep_time", ")", "try", ":", "response_or_html", "=", "downloader_func", "(", "url", ",", "*", "*", "downloader_func_kwargs", ")", "if", "isinstance", "(", "response_or_html", ",", "string_types", ")", ":", "parser_func_kwargs", "[", "\"html\"", "]", "=", "response_or_html", "else", ":", "parser_func_kwargs", "[", "\"response\"", "]", "=", "response_or_html", "post_process_response_func", "(", "response_or_html", ",", "*", "*", "post_process_response_func_kwargs", ")", "except", "Exception", "as", "e", ":", "logger", ".", "log_error", "(", "e", ")", "continue", "try", ":", "parse_result", "=", "parser_func", "(", "parent", "=", "parent_instance", ",", "*", "*", "parser_func_kwargs", ")", "parse_result", ".", "process_item", "(", "*", "*", "process_item_func_kwargs", ")", "logger", ".", "log_status", "(", "parse_result", ")", "except", "Exception", "as", "e", ":", "logger", ".", "log_error", "(", "e", ")", "continue" ]

[ "A", "standard", "one", "-", "to", "-", "many", "crawling", "workflow", "." ]

[ "def", "to_dict", "(", "self", ",", "img_coll", ")", ":", "# Get the basic Json object from the super class", "json_obj", "=", "super", "(", "DefaultImageGroupManager", ",", "self", ")", ".", "to_dict", "(", "img_coll", ")", "# Add list of images as Json array", "images", "=", "[", "]", "for", "img_group", "in", "img_coll", ".", "images", ":", "images", ".", "append", "(", "{", "'identifier'", ":", "img_group", ".", "identifier", ",", "'folder'", ":", "img_group", ".", "folder", ",", "'name'", ":", "img_group", ".", "name", "}", ")", "json_obj", "[", "'images'", "]", "=", "images", "# Transform dictionary of options into list of elements, one per typed", "# attribute in the options set.", "json_obj", "[", "'options'", "]", "=", "attribute", ".", "attributes_to_dict", "(", "img_coll", ".", "options", ")", "return", "json_obj" ]

[ "Create", "a", "Json", "-", "like", "dictionary", "for", "image", "group", ".", "Extends", "the", "basic", "object", "with", "an", "array", "of", "image", "identifiers", "." ]

[ "def", "execute", "(", "self", ")", ":", "if", "self", ".", "_decode_output", ":", "# Capture and decode system output", "with", "Popen", "(", "self", ".", "command", ",", "shell", "=", "True", ",", "stdout", "=", "PIPE", ")", "as", "process", ":", "self", ".", "_output", "=", "[", "i", ".", "decode", "(", "\"utf-8\"", ")", ".", "strip", "(", ")", "for", "i", "in", "process", ".", "stdout", "]", "self", ".", "_success", "=", "True", "else", ":", "# Execute without capturing output", "os", ".", "system", "(", "self", ".", "command", ")", "self", ".", "_success", "=", "True", "return", "self" ]

[ "Execute", "a", "system", "command", "." ]

[ "def", "is_op", "(", "call", ",", "op", ")", ":", "try", ":", "return", "call", ".", "id", "==", "op", ".", "id", "except", "Exception", "as", "e", ":", "return", "False" ]

[ ":", "param", "call", ":", "The", "specific", "operator", "instance", "(", "a", "method", "call", ")", ":", "param", "op", ":", "The", "the", "operator", "we", "are", "testing", "against", ":", "return", ":", "isinstance", "(", "call", "op", ")", "but", "faster" ]

[ "def", "resolve_placeholders", "(", "path", ",", "placeholder_dict", ")", ":", "try", ":", "if", "isinstance", "(", "path", ",", "unicode", ")", ":", "path", "=", "str", "(", "path", ")", "if", "not", "isinstance", "(", "path", ",", "str", ")", ":", "raise", "TypeError", "(", "expected_type", "=", "str", ",", "actual_type", "=", "type", "(", "path", ")", ")", "if", "'$'", "not", "in", "path", ":", "return", "path", "# Extract placeholder from path", "if", "len", "(", "path", ".", "split", "(", "'>'", ")", ")", "==", "1", ":", "placeholder", "=", "path", ".", "split", "(", "'/'", ")", "[", "0", "]", "else", ":", "if", "path", ".", "split", "(", "'>'", ")", "[", "0", "]", ".", "strip", "(", ")", ".", "startswith", "(", "'$'", ")", ":", "placeholder", "=", "path", ".", "split", "(", "'>'", ")", "[", "0", "]", ".", "strip", "(", ")", ".", "split", "(", "'/'", ")", "[", "0", "]", "else", ":", "placeholder", "=", "path", ".", "split", "(", "'>'", ")", "[", "1", "]", ".", "strip", "(", ")", ".", "split", "(", "'/'", ")", "[", "0", "]", "# SHARED", "if", "placeholder", "==", "\"$SHARED\"", ":", "return", "path", ".", "replace", "(", "placeholder", ",", "'pilot://'", ")", "# Expected placeholder format:", "# $Pipeline_{pipeline.uid}_Stage_{stage.uid}_Task_{task.uid}", "broken_placeholder", "=", "placeholder", ".", "split", "(", "'/'", ")", "[", "0", "]", ".", "split", "(", "'_'", ")", "if", "not", "len", "(", "broken_placeholder", ")", "==", "6", ":", "raise", "ValueError", "(", "obj", "=", "'placeholder'", ",", "attribute", "=", "'task'", ",", "expected_value", "=", "'$Pipeline_(pipeline_name)_Stage_(stage_name)_Task_(task_name) or $SHARED'", ",", "actual_value", "=", "broken_placeholder", ")", "pipeline_name", "=", "broken_placeholder", "[", "1", "]", "stage_name", "=", "broken_placeholder", "[", "3", "]", "task_name", "=", "broken_placeholder", "[", "5", "]", "resolved_placeholder", "=", "None", "if", "pipeline_name", "in", "placeholder_dict", ".", "keys", "(", ")", ":", "if", "stage_name", "in", "placeholder_dict", "[", "pipeline_name", "]", ".", "keys", "(", ")", ":", "if", "task_name", "in", "placeholder_dict", "[", "pipeline_name", "]", "[", "stage_name", "]", ".", "keys", "(", ")", ":", "resolved_placeholder", "=", "path", ".", "replace", "(", "placeholder", ",", "placeholder_dict", "[", "pipeline_name", "]", "[", "stage_name", "]", "[", "task_name", "]", "[", "'path'", "]", ")", "else", ":", "logger", ".", "warning", "(", "'%s not assigned to any task in Stage %s Pipeline %s'", "%", "(", "task_name", ",", "stage_name", ",", "pipeline_name", ")", ")", "else", ":", "logger", ".", "warning", "(", "'%s not assigned to any Stage in Pipeline %s'", "%", "(", "stage_name", ",", "pipeline_name", ")", ")", "else", ":", "logger", ".", "warning", "(", "'%s not assigned to any Pipeline'", "%", "(", "pipeline_name", ")", ")", "if", "not", "resolved_placeholder", ":", "logger", ".", "warning", "(", "'No placeholder could be found for task name %s \\\n stage name %s and pipeline name %s. Please be sure to \\\n use object names and not uids in your references,i.e, \\\n $Pipeline_(pipeline_name)_Stage_(stage_name)_Task_(task_name)'", ")", "raise", "ValueError", "(", "obj", "=", "'placeholder'", ",", "attribute", "=", "'task'", ",", "expected_value", "=", "'$Pipeline_(pipeline_name)_Stage_(stage_name)_Task_(task_name) or $SHARED'", ",", "actual_value", "=", "broken_placeholder", ")", "return", "resolved_placeholder", "except", "Exception", ",", "ex", ":", "logger", ".", "exception", "(", "'Failed to resolve placeholder %s, error: %s'", "%", "(", "path", ",", "ex", ")", ")", "raise" ]

[ "**", "Purpose", "**", ":", "Substitute", "placeholders", "in", "staging", "attributes", "of", "a", "Task", "with", "actual", "paths", "to", "the", "corresponding", "tasks", "." ]

[ "def", "main", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Monitor your crons with cronitor.io & sentry.io'", ",", "epilog", "=", "'https://github.com/youversion/crony'", ",", "prog", "=", "'crony'", ")", "parser", ".", "add_argument", "(", "'-c'", ",", "'--cronitor'", ",", "action", "=", "'store'", ",", "help", "=", "'Cronitor link identifier. This can be found in your Cronitor unique'", "' ping URL right after https://cronitor.link/'", ")", "parser", ".", "add_argument", "(", "'-e'", ",", "'--venv'", ",", "action", "=", "'store'", ",", "help", "=", "'Path to virtualenv to source before running script. May be passed'", "' as an argument or loaded from an environment variable or config file.'", ")", "parser", ".", "add_argument", "(", "'-d'", ",", "'--cd'", ",", "action", "=", "'store'", ",", "help", "=", "'If the script needs ran in a specific directory, than can be passed'", "' or cd can be ran prior to running crony.'", ")", "parser", ".", "add_argument", "(", "'-l'", ",", "'--log'", ",", "action", "=", "'store'", ",", "help", "=", "'Log file to direct stdout of script run to. Can be passed or '", "'defined in config file with \"log_file\"'", ")", "parser", ".", "add_argument", "(", "'-o'", ",", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'Path to a crony config file to use.'", ")", "parser", ".", "add_argument", "(", "'-p'", ",", "'--path'", ",", "action", "=", "'store'", ",", "help", "=", "'Paths to append to the PATH environment variable before running. '", "' Can be passed as an argument or loaded from config file.'", ")", "parser", ".", "add_argument", "(", "'-s'", ",", "'--dsn'", ",", "action", "=", "'store'", ",", "help", "=", "'Sentry DSN. May be passed or loaded from an environment variable '", "'or a config file.'", ")", "parser", ".", "add_argument", "(", "'-t'", ",", "'--timeout'", ",", "action", "=", "'store'", ",", "default", "=", "10", ",", "help", "=", "'Timeout to use when'", "' sending requests to Cronitor'", ",", "type", "=", "int", ")", "parser", ".", "add_argument", "(", "'-v'", ",", "'--verbose'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Increase level of verbosity'", "' output by crony'", ")", "parser", ".", "add_argument", "(", "'--version'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Output crony version # and exit'", ")", "parser", ".", "add_argument", "(", "'cmd'", ",", "nargs", "=", "argparse", ".", "REMAINDER", ",", "help", "=", "'Command to run and monitor'", ")", "cc", "=", "CommandCenter", "(", "parser", ".", "parse_args", "(", ")", ")", "sys", ".", "exit", "(", "cc", ".", "log", "(", "*", "cc", ".", "func", "(", ")", ")", ")" ]

[ "Entry", "point", "for", "running", "crony", "." ]

[ "def", "correspondence", "(", "soup", ")", ":", "correspondence", "=", "[", "]", "author_notes_nodes", "=", "raw_parser", ".", "author_notes", "(", "soup", ")", "if", "author_notes_nodes", ":", "corresp_nodes", "=", "raw_parser", ".", "corresp", "(", "author_notes_nodes", ")", "for", "tag", "in", "corresp_nodes", ":", "correspondence", ".", "append", "(", "tag", ".", "text", ")", "return", "correspondence" ]

[ "Find", "the", "corresp", "tags", "included", "in", "author", "-", "notes", "for", "primary", "correspondence" ]

[ "def", "change_profile", "(", "self", ",", "profile_name", ")", ":", "self", ".", "_server_side_completer", "=", "self", ".", "_create_server_side_completer", "(", "session", "=", "botocore", ".", "session", ".", "Session", "(", "profile", "=", "profile_name", ")", ")" ]

[ "Change", "the", "profile", "used", "for", "server", "side", "completions", "." ]

[ "def", "_make_module_refnode", "(", "self", ",", "builder", ",", "fromdocname", ",", "name", ",", "contnode", ")", ":", "# Get additional info for modules.", "docname", ",", "synopsis", ",", "platform", ",", "deprecated", "=", "self", ".", "data", "[", "'modules'", "]", "[", "name", "]", "title", "=", "name", "if", "synopsis", ":", "title", "+=", "': '", "+", "synopsis", "if", "deprecated", ":", "title", "+=", "_", "(", "' (deprecated)'", ")", "if", "platform", ":", "title", "+=", "' ('", "+", "platform", "+", "')'", "return", "make_refnode", "(", "builder", ",", "fromdocname", ",", "docname", ",", "'module-'", "+", "name", ",", "contnode", ",", "title", ")" ]

[ "Helper", "function", "to", "generate", "new", "xref", "node", "based", "on", "current", "environment", "." ]

[ "def", "openQuickSettings", "(", "self", ")", ":", "# the tablet has a different Notification/Quick Settings bar depending on x", "w23", "=", "2", "*", "self", ".", "device", ".", "display", "[", "'width'", "]", "/", "3", "s", "=", "(", "w23", ",", "0", ")", "e", "=", "(", "w23", ",", "self", ".", "device", ".", "display", "[", "'height'", "]", "/", "2", ")", "self", ".", "device", ".", "drag", "(", "s", ",", "e", ",", "500", ",", "20", ",", "-", "1", ")", "self", ".", "vc", ".", "sleep", "(", "1", ")", "if", "self", ".", "vc", ".", "getSdkVersion", "(", ")", ">=", "20", ":", "self", ".", "device", ".", "drag", "(", "s", ",", "e", ",", "500", ",", "20", ",", "-", "1", ")", "self", ".", "vc", ".", "sleep", "(", "1", ")", "self", ".", "vc", ".", "dump", "(", "-", "1", ")" ]

[ "Opens", "the", "Quick", "Settings", "shade", "." ]

[ "def", "can", "(", "self", ",", "event", ")", ":", "return", "[", "t", ".", "new_state", "for", "t", "in", "self", ".", "_transitions", "if", "t", ".", "event", ".", "equals", "(", "event", ")", "]" ]

[ "returns", "a", "list", "of", "states", "that", "can", "result", "from", "processing", "this", "event" ]

[ "def", "_sortkey", "(", "self", ",", "key", "=", "'uri'", ",", "language", "=", "'any'", ")", ":", "if", "key", "==", "'uri'", ":", "return", "self", ".", "uri", "else", ":", "l", "=", "label", "(", "self", ".", "labels", ",", "language", ",", "key", "==", "'sortlabel'", ")", "return", "l", ".", "label", ".", "lower", "(", ")", "if", "l", "else", "''" ]

[ "Provide", "a", "single", "sortkey", "for", "this", "conceptscheme", "." ]

[ "def", "disconnect", "(", "self", ",", "receipt", "=", "None", ",", "headers", "=", "None", ",", "*", "*", "keyword_headers", ")", ":", "Protocol12", ".", "disconnect", "(", "self", ",", "receipt", ",", "headers", ",", "*", "*", "keyword_headers", ")", "self", ".", "transport", ".", "stop", "(", ")" ]

[ ":", "param", "str", "receipt", ":", ":", "param", "dict", "headers", ":", ":", "param", "keyword_headers", ":" ]

[ "def", "_read_version", "(", "self", ",", "data", ")", ":", "version", "=", "ord", "(", "data", "[", "0", "]", ")", "if", "version", "not", "in", "self", ".", "VERSIONS", ":", "raise", "Exception", "(", "'Version not defined: %d'", "%", "version", ")", "return", "version" ]

[ "Read", "header", "version", "from", "data" ]

[ "def", "list", "(", "config", ")", ":", "# pragma: no cover", "client", "=", "Client", "(", ")", "client", ".", "prepare_connection", "(", ")", "key_api", "=", "API", "(", "client", ")", "for", "key", ",", "values", "in", "key_api", ".", "get_keys_from_ldap", "(", ")", ".", "items", "(", ")", ":", "print", "(", "\"{}: \"", ".", "format", "(", "key", ")", ")", "for", "value", "in", "[", "v", ".", "decode", "(", ")", "for", "v", "in", "values", "]", ":", "print", "(", "\"\\t - {}\"", ".", "format", "(", "value", ")", ")" ]

[ "List", "SSH", "public", "key", "(", "s", ")", "from", "LDAP", "." ]

[ "def", "create_env", "(", "self", ")", ":", "virtualenv", "(", "self", ".", "env", ",", "_err", "=", "sys", ".", "stderr", ")", "os", ".", "mkdir", "(", "self", ".", "env_bin", ")" ]

[ "Create", "a", "virtual", "environment", "." ]

[ "def", "status", "(", "self", ",", "status", ":", "int", ")", "->", "None", ":", "self", ".", "_status", "=", "status", "self", ".", "_message", "=", "STATUS_CODES", "[", "status", "]" ]

[ "设置响应状态" ]

[ "def", "by_filename", "(", "cls", ",", "session", ",", "release", ",", "filename", ")", ":", "return", "cls", ".", "first", "(", "session", ",", "where", "=", "(", "ReleaseFile", ".", "release_id", "==", "release", ".", "id", ",", "ReleaseFile", ".", "filename", "==", "filename", ",", ")", ")" ]

[ "Get", "a", "release", "file", "for", "a", "given", "release", "and", "a", "given", "filename", "." ]

[ "def", "optimize", "(", "self", ",", "commit", "=", "True", ",", "waitFlush", "=", "None", ",", "waitSearcher", "=", "None", ",", "maxSegments", "=", "None", ",", "handler", "=", "'update'", ")", ":", "if", "maxSegments", ":", "msg", "=", "'<optimize maxSegments=\"%d\" />'", "%", "maxSegments", "else", ":", "msg", "=", "'<optimize />'", "return", "self", ".", "_update", "(", "msg", ",", "commit", "=", "commit", ",", "waitFlush", "=", "waitFlush", ",", "waitSearcher", "=", "waitSearcher", ",", "handler", "=", "handler", ")" ]

[ "Tells", "Solr", "to", "streamline", "the", "number", "of", "segments", "used", "essentially", "a", "defragmentation", "operation", "." ]

[ "def", "load", "(", "self", ",", "filename", ",", "subset", "=", "None", ")", ":", "with", "open", "(", "filename", ",", "\"r\"", ")", "as", "f", ":", "name", "=", "None", "num_names", "=", "0", "while", "True", ":", "# read a header line", "line", "=", "f", ".", "readline", "(", ")", "if", "len", "(", "line", ")", "==", "0", ":", "break", "# process the header line", "words", "=", "line", ".", "split", "(", ")", "name", "=", "words", "[", "0", "]", "attr", "=", "self", ".", "_fields", ".", "get", "(", "name", ")", "if", "attr", "is", "None", ":", "raise", "FileFormatError", "(", "\"Wrong header: unknown field %s\"", "%", "name", ")", "if", "not", "words", "[", "1", "]", ".", "startswith", "(", "\"kind=\"", ")", ":", "raise", "FileFormatError", "(", "\"Malformatted array header line. (kind)\"", ")", "kind", "=", "words", "[", "1", "]", "[", "5", ":", "]", "expected_kind", "=", "attr", ".", "get_kind", "(", "attr", ".", "get", "(", ")", ")", "if", "kind", "!=", "expected_kind", ":", "raise", "FileFormatError", "(", "\"Wrong header: kind of field %s does not match. Got %s, expected %s\"", "%", "(", "name", ",", "kind", ",", "expected_kind", ")", ")", "skip", "=", "(", "(", "subset", "is", "not", "None", ")", "and", "(", "name", "not", "in", "subset", ")", ")", "print", "(", "words", ")", "if", "(", "words", "[", "2", "]", ".", "startswith", "(", "\"shape=(\"", ")", "and", "words", "[", "2", "]", ".", "endswith", "(", "\")\"", ")", ")", ":", "if", "not", "isinstance", "(", "attr", ",", "ArrayAttr", ")", ":", "raise", "FileFormatError", "(", "\"field '%s' is not an array.\"", "%", "name", ")", "shape", "=", "words", "[", "2", "]", "[", "7", ":", "-", "1", "]", "if", "shape", "[", "-", "1", "]", "==", "', '", ":", "shape", "=", "shape", "[", ":", "-", "1", "]", "try", ":", "shape", "=", "tuple", "(", "int", "(", "word", ")", "for", "word", "in", "shape", ".", "split", "(", "\",\"", ")", ")", "except", "ValueError", ":", "raise", "FileFormatError", "(", "\"Malformatted array header. (shape)\"", ")", "expected_shape", "=", "attr", ".", "get", "(", ")", ".", "shape", "if", "shape", "!=", "expected_shape", ":", "raise", "FileFormatError", "(", "\"Wrong header: shape of field %s does not match. Got %s, expected %s\"", "%", "(", "name", ",", "shape", ",", "expected_shape", ")", ")", "attr", ".", "load", "(", "f", ",", "skip", ")", "elif", "words", "[", "2", "]", ".", "startswith", "(", "\"value=\"", ")", ":", "if", "not", "isinstance", "(", "attr", ",", "ScalarAttr", ")", ":", "raise", "FileFormatError", "(", "\"field '%s' is not a single value.\"", "%", "name", ")", "if", "not", "skip", ":", "if", "kind", "==", "'i'", ":", "attr", ".", "set", "(", "int", "(", "words", "[", "2", "]", "[", "6", ":", "]", ")", ")", "else", ":", "attr", ".", "set", "(", "float", "(", "words", "[", "2", "]", "[", "6", ":", "]", ")", ")", "else", ":", "raise", "FileFormatError", "(", "\"Malformatted array header line. (shape/value)\"", ")", "num_names", "+=", "1", "if", "num_names", "!=", "len", "(", "self", ".", "_fields", ")", "and", "subset", "is", "None", ":", "raise", "FileFormatError", "(", "\"Some fields are missing in the file.\"", ")" ]

[ "Load", "data", "into", "the", "registered", "fields" ]

[ "def", "delete", "(", "self", ",", "fnames", "=", "None", ")", ":", "if", "fnames", "is", "None", ":", "fnames", "=", "self", ".", "get_selected_filenames", "(", ")", "multiple", "=", "len", "(", "fnames", ")", ">", "1", "yes_to_all", "=", "None", "for", "fname", "in", "fnames", ":", "if", "fname", "==", "self", ".", "proxymodel", ".", "path_list", "[", "0", "]", ":", "self", ".", "sig_delete_project", ".", "emit", "(", ")", "else", ":", "yes_to_all", "=", "self", ".", "delete_file", "(", "fname", ",", "multiple", ",", "yes_to_all", ")", "if", "yes_to_all", "is", "not", "None", "and", "not", "yes_to_all", ":", "# Canceled\r", "break" ]

[ "Delete", "files" ]

[ "def", "_use_gl", "(", "objs", ")", ":", "from", ".", ".", "models", ".", "plots", "import", "Plot", "return", "_any", "(", "objs", ",", "lambda", "obj", ":", "isinstance", "(", "obj", ",", "Plot", ")", "and", "obj", ".", "output_backend", "==", "\"webgl\"", ")" ]

[ "Whether", "a", "collection", "of", "Bokeh", "objects", "contains", "a", "plot", "requesting", "WebGL" ]

[ "def", "has_role_collective", "(", "self", ",", "role_s", ",", "logical_operator", "=", "all", ")", ":", "if", "self", ".", "authorized", ":", "return", "self", ".", "security_manager", ".", "has_role_collective", "(", "self", ".", "identifiers", ",", "role_s", ",", "logical_operator", ")", "else", ":", "msg", "=", "'Cannot check permission when identifiers aren\\'t set!'", "raise", "ValueError", "(", "msg", ")" ]

[ ":", "param", "role_s", ":", "1", "..", "N", "role", "identifier", ":", "type", "role_s", ":", "a", "Set", "of", "Strings" ]

[ "def", "get_current_price", "(", "fsyms", ",", "tsyms", ",", "e", "=", "'all'", ",", "try_conversion", "=", "True", ",", "full", "=", "False", ",", "format", "=", "'raw'", ")", ":", "# select API function based on 'full' parameter value\r", "if", "not", "full", ":", "func", "=", "'pricemulti'", "else", ":", "func", "=", "'pricemultifull'", "# convert single fsym and tsym input to single element lists\r", "if", "not", "isinstance", "(", "fsyms", ",", "list", ")", ":", "fsyms", "=", "[", "fsyms", "]", "if", "not", "isinstance", "(", "tsyms", ",", "list", ")", ":", "tsyms", "=", "[", "tsyms", "]", "# load data\r", "url", "=", "build_url", "(", "func", ",", "fsyms", "=", "fsyms", ",", "tsyms", "=", "tsyms", ",", "e", "=", "e", ",", "try_conversion", "=", "try_conversion", ")", "data", "=", "load_data", "(", "url", ")", "# select right format to return for full requests\r", "if", "full", "and", "format", "==", "'raw'", ":", "data", "=", "data", "[", "'RAW'", "]", "elif", "full", "and", "format", "==", "'display'", ":", "data", "=", "data", "[", "'DISPLAY'", "]", "return", "data" ]

[ "Get", "latest", "trading", "price", "or", "full", "trading", "information", "in", "display", "or", "raw", "format", "for", "the", "specified", "FROM", "/", "TO", "currency", "pairs", ".", "Args", ":", "fsyms", ":", "Single", "string", "or", "list", "of", "FROM", "symbols", ".", "tsyms", ":", "Single", "string", "or", "list", "of", "TO", "symbols", ".", "e", ":", "Default", "returns", "average", "price", "across", "all", "exchanges", ".", "Can", "be", "set", "to", "the", "name", "of", "a", "single", "exchange", ".", "try_conversion", ":", "If", "the", "crypto", "does", "not", "trade", "directly", "into", "the", "toSymbol", "requested", "BTC", "will", "be", "used", "for", "conversion", ".", "If", "set", "to", "false", "it", "will", "try", "to", "get", "values", "without", "using", "any", "conversion", "at", "all", ".", "full", ":", "Default", "of", "False", "returns", "only", "the", "latest", "price", ".", "True", "returns", "the", "following", "dictionary", "structure", "containing", "the", "full", "trading", "info", ":", "format", ":", "Default", "returns", "the", "RAW", "format", ".", "Can", "be", "set", "to", "DISPLAY", "format", ".", "Returns", ":", "Returns", "a", "dictionary", "containing", "the", "latest", "price", "pairs", "if", "full", "is", "set", "to", "false", ":", "{", "fsym1", ":", "{", "tsym1", ":", "...", "tsym2", ":", "...", "...", "}", "fsym2", ":", "{", "...", "}", "...", "}", "or", "full", "trading", "info", "dictionaries", "for", "all", "the", "price", "pairs", "in", "the", "other", "case", ":", "{", "fsym1", ":", "{", "tsym1", ":", "{", "CHANGE24HOUR", ":", "...", "CHANGEPCT24HOUR", ":", "...", "FLAGS", ":", "...", "FROMSYMBOL", ":", "...", "HIGH24HOUR", ":", "...", "LASTMARKET", ":", "...", "LASTTRADEID", ":", "...", "LASTUPDATE", ":", "...", "LASTVOLUME", ":", "...", "LASTVOLUMETO", ":", "...", "LOW24HOUR", ":", "...", "MARKET", "...", "MKTCAP", ":", "...", "OPEN24HOUR", ":", "...", "PRICE", ":", "...", "SUPPLY", ":", "...", "TOSYMBOL", ":", "...", "TYPE", ":", "...", "VOLUME24HOUR", ":", "...", "VOLUME24HOURTO", ":", "...", "}", "tsym2", ":", "...", "...", "}", "fsym2", ":", "{", "...", "}", "...", "}" ]

[ "def", "register_file", "(", "self", ",", "file", ")", ":", "not", "self", ".", "__engine", ".", "file_system_events_manager", ".", "is_path_registered", "(", "file", ")", "and", "self", ".", "__engine", ".", "file_system_events_manager", ".", "register_path", "(", "file", ")", "return", "True" ]

[ "Registers", "given", "file", "in", "the", "**", "file_system_events_manager", "**", "." ]

[ "def", "_calc_sdof_tf", "(", "self", ",", "osc_freq", ",", "damping", "=", "0.05", ")", ":", "return", "(", "-", "osc_freq", "**", "2.", "/", "(", "np", ".", "square", "(", "self", ".", "freqs", ")", "-", "np", ".", "square", "(", "osc_freq", ")", "-", "2.j", "*", "damping", "*", "osc_freq", "*", "self", ".", "freqs", ")", ")" ]

[ "Compute", "the", "transfer", "function", "for", "a", "single", "-", "degree", "-", "of", "-", "freedom", "oscillator", "." ]

[ "def", "use_general_sv_bins", "(", "data", ")", ":", "if", "any", "(", "[", "c", "in", "dd", ".", "get_svcaller", "(", "data", ")", "for", "c", "in", "[", "\"cnvkit\"", ",", "\"titancna\"", ",", "\"purecn\"", ",", "\"gatk-cnv\"", "]", "]", ")", ":", "if", "not", "_get_original_coverage", "(", "data", ")", ":", "return", "True", "return", "False" ]

[ "Check", "if", "we", "should", "use", "a", "general", "binning", "approach", "for", "a", "sample", "." ]

[ "def", "_login", "(", "self", ",", "username", "=", "\"\"", ",", "password", "=", "\"\"", ")", ":", "self", ".", "log", ".", "debug", "(", "\"----------------\"", ")", "self", ".", "log", ".", "debug", "(", "\"Logging in (username: %s)...\"", "%", "username", ")", "def", "run_query", "(", ")", ":", "return", "self", ".", "_xmlrpc_server", ".", "LogIn", "(", "username", ",", "password", ",", "self", ".", "language", ",", "self", ".", "user_agent", ")", "info", "=", "self", ".", "_safe_exec", "(", "run_query", ",", "None", ")", "if", "info", "is", "None", ":", "self", ".", "_token", "=", "None", "return", "False", "self", ".", "log", ".", "debug", "(", "\"Login ended in %s with status: %s\"", "%", "(", "info", "[", "'seconds'", "]", ",", "info", "[", "'status'", "]", ")", ")", "if", "info", "[", "'status'", "]", "==", "\"200 OK\"", ":", "self", ".", "log", ".", "debug", "(", "\"Session ID: %s\"", "%", "info", "[", "'token'", "]", ")", "self", ".", "log", ".", "debug", "(", "\"----------------\"", ")", "self", ".", "_token", "=", "info", "[", "'token'", "]", "return", "True", "else", ":", "# force token reset", "self", ".", "log", ".", "debug", "(", "\"----------------\"", ")", "self", ".", "_token", "=", "None", "return", "False" ]

[ "Login", "to", "the", "Server", "using", "username", "/", "password", "empty", "parameters", "means", "an", "anonymously", "login", "Returns", "True", "if", "login", "sucessful", "and", "False", "if", "not", "." ]

[ "def", "apply_K", "(", "df", ",", "k", ")", ":", "if", "'k'", "not", "in", "df", ".", "columns", ":", "df", "[", "'k'", "]", "=", "k", "if", "'rho_a'", "not", "in", "df", ".", "columns", ":", "df", "[", "'rho_a'", "]", "=", "df", "[", "'r'", "]", "*", "df", "[", "'k'", "]", "if", "'sigma_a'", "not", "in", "df", ".", "columns", ":", "df", "[", "'sigma_a'", "]", "=", "1.0", "/", "df", "[", "'rho_a'", "]", "if", "'Zt'", "in", "df", ".", "columns", ":", "df", "[", "'rho_a_complex'", "]", "=", "df", "[", "'Zt'", "]", "*", "df", "[", "'k'", "]", "return", "df" ]

[ "Apply", "the", "geometric", "factors", "to", "the", "dataset", "and", "compute", "(", "apparent", ")", "resistivities", "/", "conductivities" ]

[ "def", "write_file", "(", "self", ",", "filename", ",", "contents", ")", ":", "logger", ".", "info", "(", "\"Writing file: %s\"", ",", "format_path", "(", "filename", ")", ")", "contents", "=", "contents", ".", "rstrip", "(", ")", "+", "b\"\\n\"", "self", ".", "context", ".", "write_file", "(", "filename", ",", "contents", ")", "logger", ".", "debug", "(", "\"Wrote %s to %s.\"", ",", "pluralize", "(", "len", "(", "contents", ".", "splitlines", "(", ")", ")", ",", "\"line\"", ")", ",", "format_path", "(", "filename", ")", ")" ]

[ "Write", "a", "text", "file", "and", "provide", "feedback", "to", "the", "user", "." ]

[ "def", "_is_ipv4_like", "(", "s", ")", ":", "parts", "=", "s", ".", "split", "(", "'.'", ")", "if", "len", "(", "parts", ")", "!=", "4", ":", "return", "False", "for", "part", "in", "parts", ":", "try", ":", "int", "(", "part", ")", "except", "ValueError", ":", "return", "False", "return", "True" ]

[ "Find", "if", "a", "string", "superficially", "looks", "like", "an", "IPv4", "address", "." ]

[ "def", "findall", "(", "self", ",", "*", "*", "kwargs", ")", ":", "if", "(", "len", "(", "kwargs", ")", "==", "1", ")", "and", "(", "\"name\"", "in", "kwargs", ")", ":", "# Filtering on name; use the more efficient method.", "nm", "=", "kwargs", "[", "\"name\"", "]", ".", "lower", "(", ")", "uri", "=", "\"/%s?name=%s\"", "%", "(", "self", ".", "uri_base", ",", "nm", ")", "matches", "=", "self", ".", "_list", "(", "uri", ",", "list_all", "=", "True", ")", "return", "[", "match", "for", "match", "in", "matches", "if", "match", ".", "name", ".", "lower", "(", ")", "==", "nm", "]", "else", ":", "return", "super", "(", "CloudDNSManager", ",", "self", ")", ".", "findall", "(", "*", "*", "kwargs", ")" ]

[ "Finds", "all", "items", "with", "attributes", "matching", "**", "kwargs", "." ]