Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Load", "vertices", "and", "edges", "from", "a", "file", "." ]

[ "def", "load_from_file", "(", "self", ",", "wire_file", ")", ":", "self", ".", "raw_wires", "=", "PyMesh", ".", "WireNetwork", ".", "create", "(", "wire_file", ")", "self", ".", "__initialize_wires", "(", ")" ]

[ "Serializes", "the", "protocol", "message", "to", "a", "binary", "string", "." ]

[ "def", "SerializeToString", "(", "self", ")", ":", "raise", "NotImplementedError" ]

[ "Microsoft", "Universal", "C", "Runtime", "SDK", "Include", "." ]

[ "def", "UCRTIncludes", "(", "self", ")", ":", "if", "self", ".", "vs_ver", "<", "14.0", ":", "return", "[", "]", "include", "=", "join", "(", "self", ".", "si", ".", "UniversalCRTSdkDir", ",", "'include'", ")", "return", "[", "join", "(", "include", ",", "'%sucrt'", "%", "self", ".", "_ucrt_subdir", ")", "]" ]

[ "Updates", "the", "internal", "evaluation", "result", ":", "math", ":", "preds", "and", ":", "math", ":", "labels", "." ]

[ "def", "update", "(", "self", ",", "*", "inputs", ")", ":", "if", "len", "(", "inputs", ")", "!=", "2", ":", "raise", "ValueError", "(", "\"For 'Perplexity.update', it needs 2 inputs (predicted value, label), but got {}.\"", ".", "format", "(", "len", "(", "inputs", ")", ")", ")", "preds", "=", "[", "self", ".", "_convert_data", "(", "inputs", "[", "0", "]", ")", "]", "labels", "=", "[", "self", ".", "_convert_data", "(", "inputs", "[", "1", "]", ")", "]", "if", "len", "(", "preds", ")", "!=", "len", "(", "labels", ")", ":", "raise", "RuntimeError", "(", "\"For 'Perplexity.update', predicted value (input[0]) and label (input[1]) should have \"", "\"the same length, but got predicted value length {}, label length {}.\"", ".", "format", "(", "len", "(", "preds", ")", ",", "len", "(", "labels", ")", ")", ")", "loss", "=", "0.", "num", "=", "0", "for", "label", ",", "pred", "in", "zip", "(", "labels", ",", "preds", ")", ":", "if", "label", ".", "size", "!=", "pred", ".", "size", "/", "pred", ".", "shape", "[", "-", "1", "]", ":", "raise", "RuntimeError", "(", "\"For 'Perplexity.update', predicted value (input[0]) and label (input[1]) should \"", "\"have the same shape, but got predicted value shape {}, label shape {}.\"", ".", "format", "(", "pred", ".", "shape", ",", "label", ".", "shape", ")", ")", "label", "=", "label", ".", "reshape", "(", "(", "label", ".", "size", ",", ")", ")", "label_expand", "=", "label", ".", "astype", "(", "int", ")", "label_expand", "=", "np", ".", "expand_dims", "(", "label_expand", ",", "axis", "=", "1", ")", "first_indices", "=", "np", ".", "arange", "(", "label_expand", ".", "shape", "[", "0", "]", ")", "[", ":", ",", "None", "]", "pred", "=", "np", ".", "squeeze", "(", "pred", "[", "first_indices", ",", "label_expand", "]", ")", "if", "self", ".", "ignore_label", "is", "not", "None", ":", "ignore", "=", "(", "label", "==", "self", ".", "ignore_label", ")", ".", "astype", "(", "pred", ".", "dtype", ")", "num", "-=", "np", ".", "sum", "(", "ignore", ")", "pred", "=", "pred", "*", "(", "1", "-", "ignore", ")", "+", "ignore", "loss", "-=", "np", ".", "sum", "(", "np", ".", "log", "(", "np", ".", "maximum", "(", "1e-10", ",", "pred", ")", ")", ")", "num", "+=", "pred", ".", "size", "self", ".", "_sum_metric", "+=", "loss", "self", ".", "_num_inst", "+=", "num" ]

[ "Prepend", "values", "to", "existing", "construction", "variables", "in", "an", "Environment", "if", "they", "re", "not", "already", "there", ".", "If", "delete_existing", "is", "1", "removes", "existing", "values", "first", "so", "values", "move", "to", "front", "." ]

[ "def", "PrependUnique", "(", "self", ",", "delete_existing", "=", "0", ",", "*", "*", "kw", ")", ":", "kw", "=", "copy_non_reserved_keywords", "(", "kw", ")", "for", "key", ",", "val", "in", "kw", ".", "items", "(", ")", ":", "if", "is_List", "(", "val", ")", ":", "val", "=", "_delete_duplicates", "(", "val", ",", "not", "delete_existing", ")", "if", "key", "not", "in", "self", ".", "_dict", "or", "self", ".", "_dict", "[", "key", "]", "in", "(", "''", ",", "None", ")", ":", "self", ".", "_dict", "[", "key", "]", "=", "val", "elif", "is_Dict", "(", "self", ".", "_dict", "[", "key", "]", ")", "and", "is_Dict", "(", "val", ")", ":", "self", ".", "_dict", "[", "key", "]", ".", "update", "(", "val", ")", "elif", "is_List", "(", "val", ")", ":", "dk", "=", "self", ".", "_dict", "[", "key", "]", "if", "not", "is_List", "(", "dk", ")", ":", "dk", "=", "[", "dk", "]", "if", "delete_existing", ":", "dk", "=", "[", "x", "for", "x", "in", "dk", "if", "x", "not", "in", "val", "]", "else", ":", "val", "=", "[", "x", "for", "x", "in", "val", "if", "x", "not", "in", "dk", "]", "self", ".", "_dict", "[", "key", "]", "=", "val", "+", "dk", "else", ":", "dk", "=", "self", ".", "_dict", "[", "key", "]", "if", "is_List", "(", "dk", ")", ":", "# By elimination, val is not a list. Since dk is a", "# list, wrap val in a list first.", "if", "delete_existing", ":", "dk", "=", "[", "x", "for", "x", "in", "dk", "if", "x", "not", "in", "val", "]", "self", ".", "_dict", "[", "key", "]", "=", "[", "val", "]", "+", "dk", "else", ":", "if", "val", "not", "in", "dk", ":", "self", ".", "_dict", "[", "key", "]", "=", "[", "val", "]", "+", "dk", "else", ":", "if", "delete_existing", ":", "dk", "=", "[", "x", "for", "x", "in", "dk", "if", "x", "not", "in", "val", "]", "self", ".", "_dict", "[", "key", "]", "=", "val", "+", "dk", "self", ".", "scanner_map_delete", "(", "kw", ")" ]

[ "Applies", "a", "function", "to", "1", "-", "D", "slices", "along", "the", "given", "axis", ".", "Executes", "func1d", "(", "a", "*", "args", "**", "kwargs", ")", "where", "func1d", "operates", "on", "1", "-", "D", "arrays", "and", "a", "is", "a", "1", "-", "D", "slice", "of", "arr", "along", "axis", "." ]

[ "def", "apply_along_axis", "(", "func1d", ",", "axis", ",", "arr", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "ndim", "=", "F", ".", "rank", "(", "arr", ")", "shape", "=", "F", ".", "shape", "(", "arr", ")", "axis", "=", "_check_axis_in_range", "(", "axis", ",", "ndim", ")", "arr", "=", "moveaxis", "(", "arr", ",", "axis", ",", "-", "1", ")", "arr", "=", "F", ".", "reshape", "(", "arr", ",", "(", "-", "1", ",", "F", ".", "shape", "(", "arr", ")", "[", "-", "1", "]", ")", ")", "slices", "=", "[", "]", "for", "i", "in", "range", "(", "F", ".", "shape", "(", "arr", ")", "[", "0", "]", ")", ":", "slices", ".", "append", "(", "func1d", "(", "arr", "[", "i", "]", ",", "*", "args", ",", "*", "*", "kwargs", ")", ")", "stacked_slices", "=", "stack", "(", "slices", ")", "shape_stacked", "=", "(", "_tuple_slice", "(", "shape", ",", "None", ",", "axis", ")", "+", "_tuple_slice", "(", "shape", ",", "axis", "+", "1", ",", "None", ")", "+", "_tuple_slice", "(", "F", ".", "shape", "(", "stacked_slices", ")", ",", "1", ",", "None", ")", ")", "res", "=", "F", ".", "reshape", "(", "stacked_slices", ",", "shape_stacked", ")", "# moves the dimensions returned by `func1d` back to `axis`", "ndim_func", "=", "F", ".", "rank", "(", "res", ")", "-", "ndim", "+", "1", "if", "ndim_func", ">=", "1", ":", "res", "=", "moveaxis", "(", "res", ",", "F", ".", "make_range", "(", "ndim", "-", "1", ",", "F", ".", "rank", "(", "res", ")", ")", ",", "F", ".", "make_range", "(", "axis", ",", "axis", "+", "ndim_func", ")", ")", "return", "res" ]

[ "Return", "the", "underlying", "type", "of", "a", "typedef", "declaration", "." ]

[ "def", "underlying_typedef_type", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_underlying_type'", ")", ":", "assert", "self", ".", "kind", ".", "is_declaration", "(", ")", "self", ".", "_underlying_type", "=", "conf", ".", "lib", ".", "clang_getTypedefDeclUnderlyingType", "(", "self", ")", "return", "self", ".", "_underlying_type" ]

[ "Iterates", "over", "all", "the", "targets", "of", "the", "given", "BUILD", ".", "gn", "file", "and", "verifies", "that", "the", "source", "files", "referenced", "by", "it", "don", "t", "belong", "to", "any", "of", "it", "s", "subpackages", ".", "Returns", "an", "iterator", "over", "PackageBoundaryViolations", "for", "this", "package", "." ]

[ "def", "_CheckBuildFile", "(", "build_file_path", ",", "packages", ")", ":", "package", "=", "os", ".", "path", ".", "dirname", "(", "build_file_path", ")", "subpackages_re", "=", "_BuildSubpackagesPattern", "(", "packages", ",", "package", ")", "build_file_contents", "=", "_ReadFileAndPrependLines", "(", "build_file_path", ")", "for", "target_match", "in", "TARGET_RE", ".", "finditer", "(", "build_file_contents", ")", ":", "target_name", "=", "target_match", ".", "group", "(", "'target_name'", ")", "target_contents", "=", "target_match", ".", "group", "(", "'target_contents'", ")", "for", "sources_match", "in", "SOURCES_RE", ".", "finditer", "(", "target_contents", ")", ":", "sources", "=", "sources_match", ".", "group", "(", "'sources'", ")", "for", "subpackages_match", "in", "subpackages_re", ".", "finditer", "(", "sources", ")", ":", "subpackage", "=", "subpackages_match", ".", "group", "(", "'subpackage'", ")", "source_file", "=", "subpackages_match", ".", "group", "(", "'source_file'", ")", "if", "subpackage", ":", "yield", "PackageBoundaryViolation", "(", "build_file_path", ",", "target_name", ",", "source_file", ",", "subpackage", ")" ]

[ "Logs", "an", "error", "if", "no", "Copyright", "message", "appears", "at", "the", "top", "of", "the", "file", "." ]

[ "def", "CheckForCopyright", "(", "filename", ",", "lines", ",", "error", ")", ":", "# We'll say it should occur by line 10. Don't forget there's a", "# dummy line at the front.", "for", "line", "in", "xrange", "(", "1", ",", "min", "(", "len", "(", "lines", ")", ",", "11", ")", ")", ":", "if", "re", ".", "search", "(", "r'Copyright'", ",", "lines", "[", "line", "]", ",", "re", ".", "I", ")", ":", "break", "else", ":", "# means no copyright line was found", "error", "(", "filename", ",", "0", ",", "'legal/copyright'", ",", "5", ",", "'No copyright message found. '", "'You should have a line: \"Copyright [year] <Copyright Owner>\"'", ")" ]

[ "CanDragColMove", "(", "self", ")", "-", ">", "bool" ]

[ "def", "CanDragColMove", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "Grid_CanDragColMove", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Heterogeneous", "stack", "." ]

[ "def", "__init__", "(", "self", ",", "document", ",", "babel_class", "=", "Babel", ")", ":", "nodes", ".", "NodeVisitor", ".", "__init__", "(", "self", ",", "document", ")", "# Reporter", "# ~~~~~~~~", "self", ".", "warn", "=", "self", ".", "document", ".", "reporter", ".", "warning", "self", ".", "error", "=", "self", ".", "document", ".", "reporter", ".", "error", "# Settings", "# ~~~~~~~~", "self", ".", "settings", "=", "settings", "=", "document", ".", "settings", "self", ".", "latex_encoding", "=", "self", ".", "to_latex_encoding", "(", "settings", ".", "output_encoding", ")", "self", ".", "use_latex_toc", "=", "settings", ".", "use_latex_toc", "self", ".", "use_latex_docinfo", "=", "settings", ".", "use_latex_docinfo", "self", ".", "_use_latex_citations", "=", "settings", ".", "use_latex_citations", "self", ".", "_reference_label", "=", "settings", ".", "reference_label", "self", ".", "hyperlink_color", "=", "settings", ".", "hyperlink_color", "self", ".", "compound_enumerators", "=", "settings", ".", "compound_enumerators", "self", ".", "font_encoding", "=", "getattr", "(", "settings", ",", "'font_encoding'", ",", "''", ")", "self", ".", "section_prefix_for_enumerators", "=", "(", "settings", ".", "section_prefix_for_enumerators", ")", "self", ".", "section_enumerator_separator", "=", "(", "settings", ".", "section_enumerator_separator", ".", "replace", "(", "'_'", ",", "r'\\_'", ")", ")", "# literal blocks:", "self", ".", "literal_block_env", "=", "'alltt'", "self", ".", "literal_block_options", "=", "''", "if", "settings", ".", "literal_block_env", "!=", "''", ":", "(", "none", ",", "self", ".", "literal_block_env", ",", "self", ".", "literal_block_options", ",", "none", ")", "=", "re", ".", "split", "(", "r'(\\w+)(.*)'", ",", "settings", ".", "literal_block_env", ")", "elif", "settings", ".", "use_verbatim_when_possible", ":", "self", ".", "literal_block_env", "=", "'verbatim'", "#", "if", "self", ".", "settings", ".", "use_bibtex", ":", "self", ".", "bibtex", "=", "self", ".", "settings", ".", "use_bibtex", ".", "split", "(", "','", ",", "1", ")", "# TODO avoid errors on not declared citations.", "else", ":", "self", ".", "bibtex", "=", "None", "# language module for Docutils-generated text", "# (labels, bibliographic_fields, and author_separators)", "self", ".", "language_module", "=", "languages", ".", "get_language", "(", "settings", ".", "language_code", ",", "document", ".", "reporter", ")", "self", ".", "babel", "=", "babel_class", "(", "settings", ".", "language_code", ",", "document", ".", "reporter", ")", "self", ".", "author_separator", "=", "self", ".", "language_module", ".", "author_separators", "[", "0", "]", "d_options", "=", "[", "self", ".", "settings", ".", "documentoptions", "]", "if", "self", ".", "babel", ".", "language", "not", "in", "(", "'english'", ",", "''", ")", ":", "d_options", ".", "append", "(", "self", ".", "babel", ".", "language", ")", "self", ".", "documentoptions", "=", "','", ".", "join", "(", "filter", "(", "None", ",", "d_options", ")", ")", "self", ".", "d_class", "=", "DocumentClass", "(", "settings", ".", "documentclass", ",", "settings", ".", "use_part_section", ")", "# graphic package options:", "if", "self", ".", "settings", ".", "graphicx_option", "==", "''", ":", "self", ".", "graphicx_package", "=", "r'\\usepackage{graphicx}'", "elif", "self", ".", "settings", ".", "graphicx_option", ".", "lower", "(", ")", "==", "'auto'", ":", "self", ".", "graphicx_package", "=", "PreambleCmds", ".", "graphicx_auto", "else", ":", "self", ".", "graphicx_package", "=", "(", "r'\\usepackage[%s]{graphicx}'", "%", "self", ".", "settings", ".", "graphicx_option", ")", "# footnotes:", "self", ".", "docutils_footnotes", "=", "settings", ".", "docutils_footnotes", "# @@ table_style: list of values from fixed set: warn?", "# for s in self.settings.table_style:", "# if s not in Writer.table_style_values:", "# self.warn('Ignoring value \"%s\" in \"table-style\" setting.' %s)", "# Output collection stacks", "# ~~~~~~~~~~~~~~~~~~~~~~~~", "# Document parts", "self", ".", "head_prefix", "=", "[", "r'\\documentclass[%s]{%s}'", "%", "(", "self", ".", "documentoptions", ",", "self", ".", "settings", ".", "documentclass", ")", "]", "self", ".", "requirements", "=", "SortableDict", "(", ")", "# made a list in depart_document()", "self", ".", "requirements", "[", "'__static'", "]", "=", "r'\\usepackage{ifthen}'", "self", ".", "latex_preamble", "=", "[", "settings", ".", "latex_preamble", "]", "self", ".", "fallbacks", "=", "SortableDict", "(", ")", "# made a list in depart_document()", "self", ".", "pdfsetup", "=", "[", "]", "# PDF properties (hyperref package)", "self", ".", "title", "=", "[", "]", "self", ".", "subtitle", "=", "[", "]", "self", ".", "titledata", "=", "[", "]", "# \\title, \\author, \\date", "## self.body_prefix = ['\\\\begin{document}\\n']", "self", ".", "body_pre_docinfo", "=", "[", "]", "# \\maketitle", "self", ".", "docinfo", "=", "[", "]", "self", ".", "dedication", "=", "[", "]", "self", ".", "abstract", "=", "[", "]", "self", ".", "body", "=", "[", "]", "## self.body_suffix = ['\\\\end{document}\\n']", "self", ".", "context", "=", "[", "]", "# Title metadata:", "self", ".", "title_labels", "=", "[", "]", "self", ".", "subtitle_labels", "=", "[", "]", "# (if use_latex_docinfo: collects lists of", "# author/organization/contact/address lines)", "self", ".", "author_stack", "=", "[", "]", "self", ".", "date", "=", "[", "]", "# PDF properties: pdftitle, pdfauthor", "# TODO?: pdfcreator, pdfproducer, pdfsubject, pdfkeywords", "self", ".", "pdfinfo", "=", "[", "]", "self", ".", "pdfauthor", "=", "[", "]", "# Stack of section counters so that we don't have to use_latex_toc.", "# This will grow and shrink as processing occurs.", "# Initialized for potential first-level sections.", "self", ".", "_section_number", "=", "[", "0", "]", "# The current stack of enumerations so that we can expand", "# them into a compound enumeration.", "self", ".", "_enumeration_counters", "=", "[", "]", "# The maximum number of enumeration counters we've used.", "# If we go beyond this number, we need to create a new", "# counter; otherwise, just reuse an old one.", "self", ".", "_max_enumeration_counters", "=", "0", "self", ".", "_bibitems", "=", "[", "]", "# object for a table while proccessing.", "self", ".", "table_stack", "=", "[", "]", "self", ".", "active_table", "=", "Table", "(", "self", ",", "'longtable'", ")", "# Where to collect the output of visitor methods (default: body)", "self", ".", "out", "=", "self", ".", "body", "self", ".", "out_stack", "=", "[", "]", "# stack of output collectors", "# Process settings", "# ~~~~~~~~~~~~~~~~", "# Encodings:", "# Docutils' output-encoding => TeX input encoding", "if", "self", ".", "latex_encoding", "!=", "'ascii'", ":", "self", ".", "requirements", "[", "'_inputenc'", "]", "=", "(", "r'\\usepackage[%s]{inputenc}'", "%", "self", ".", "latex_encoding", ")", "# TeX font encoding", "if", "not", "self", ".", "is_xetex", ":", "if", "self", ".", "font_encoding", ":", "self", ".", "requirements", "[", "'_fontenc'", "]", "=", "(", "r'\\usepackage[%s]{fontenc}'", "%", "self", ".", "font_encoding", ")", "# ensure \\textquotedbl is defined:", "for", "enc", "in", "self", ".", "font_encoding", ".", "split", "(", "','", ")", ":", "enc", "=", "enc", ".", "strip", "(", ")", "if", "enc", "==", "'OT1'", ":", "self", ".", "requirements", "[", "'_textquotedblOT1'", "]", "=", "(", "r'\\DeclareTextSymbol{\\textquotedbl}{OT1}{`\\\"}'", ")", "elif", "enc", "not", "in", "(", "'T1'", ",", "'T2A'", ",", "'T2B'", ",", "'T2C'", ",", "'T4'", ",", "'T5'", ")", ":", "self", ".", "requirements", "[", "'_textquotedbl'", "]", "=", "(", "r'\\DeclareTextSymbolDefault{\\textquotedbl}{T1}'", ")", "# page layout with typearea (if there are relevant document options)", "if", "(", "settings", ".", "documentclass", ".", "find", "(", "'scr'", ")", "==", "-", "1", "and", "(", "self", ".", "documentoptions", ".", "find", "(", "'DIV'", ")", "!=", "-", "1", "or", "self", ".", "documentoptions", ".", "find", "(", "'BCOR'", ")", "!=", "-", "1", ")", ")", ":", "self", ".", "requirements", "[", "'typearea'", "]", "=", "r'\\usepackage{typearea}'", "# Stylesheets", "# (the name `self.stylesheet` is singular because only one", "# stylesheet was supported before Docutils 0.6).", "self", ".", "stylesheet", "=", "[", "self", ".", "stylesheet_call", "(", "path", ")", "for", "path", "in", "utils", ".", "get_stylesheet_list", "(", "settings", ")", "]", "# PDF setup", "if", "self", ".", "hyperlink_color", "in", "(", "'0'", ",", "'false'", ",", "'False'", ",", "''", ")", ":", "self", ".", "hyperref_options", "=", "''", "else", ":", "self", ".", "hyperref_options", "=", "'colorlinks=true,linkcolor=%s,urlcolor=%s'", "%", "(", "self", ".", "hyperlink_color", ",", "self", ".", "hyperlink_color", ")", "if", "settings", ".", "hyperref_options", ":", "self", ".", "hyperref_options", "+=", "','", "+", "settings", ".", "hyperref_options", "# LaTeX Toc", "# include all supported sections in toc and PDF bookmarks", "# (or use documentclass-default (as currently))?", "## if self.use_latex_toc:", "## self.requirements['tocdepth'] = (r'\\setcounter{tocdepth}{%d}' %", "## len(self.d_class.sections))", "# Section numbering", "if", "settings", ".", "sectnum_xform", ":", "# section numbering by Docutils", "PreambleCmds", ".", "secnumdepth", "=", "r'\\setcounter{secnumdepth}{0}'", "else", ":", "# section numbering by LaTeX:", "secnumdepth", "=", "settings", ".", "sectnum_depth", "# Possible values of settings.sectnum_depth:", "# None \"sectnum\" directive without depth arg -> LaTeX default", "# 0 no \"sectnum\" directive -> no section numbers", "# >0 value of \"depth\" argument -> translate to LaTeX levels:", "# -1 part (0 with \"article\" document class)", "# 0 chapter (missing in \"article\" document class)", "# 1 section", "# 2 subsection", "# 3 subsubsection", "# 4 paragraph", "# 5 subparagraph", "if", "secnumdepth", "is", "not", "None", ":", "# limit to supported levels", "secnumdepth", "=", "min", "(", "secnumdepth", ",", "len", "(", "self", ".", "d_class", ".", "sections", ")", ")", "# adjust to document class and use_part_section settings", "if", "'chapter'", "in", "self", ".", "d_class", ".", "sections", ":", "secnumdepth", "-=", "1", "if", "self", ".", "d_class", ".", "sections", "[", "0", "]", "==", "'part'", ":", "secnumdepth", "-=", "1", "PreambleCmds", ".", "secnumdepth", "=", "r'\\setcounter{secnumdepth}{%d}'", "%", "secnumdepth", "# start with specified number:", "if", "(", "hasattr", "(", "settings", ",", "'sectnum_start'", ")", "and", "settings", ".", "sectnum_start", "!=", "1", ")", ":", "self", ".", "requirements", "[", "'sectnum_start'", "]", "=", "(", "r'\\setcounter{%s}{%d}'", "%", "(", "self", ".", "d_class", ".", "sections", "[", "0", "]", ",", "settings", ".", "sectnum_start", "-", "1", ")", ")" ]

[ "Adds", "an", "enforcement", "literal", "to", "the", "constraint", "." ]

[ "def", "OnlyEnforceIf", "(", "self", ",", "boolvar", ")", ":", "if", "cmh", ".", "is_integral", "(", "boolvar", ")", "and", "int", "(", "boolvar", ")", "==", "1", ":", "# Always true. Do nothing.", "pass", "elif", "isinstance", "(", "boolvar", ",", "list", ")", ":", "for", "b", "in", "boolvar", ":", "if", "cmh", ".", "is_integral", "(", "b", ")", "and", "int", "(", "b", ")", "==", "1", ":", "pass", "else", ":", "self", ".", "__constraint", ".", "enforcement_literal", ".", "append", "(", "b", ".", "Index", "(", ")", ")", "else", ":", "self", ".", "__constraint", ".", "enforcement_literal", ".", "append", "(", "boolvar", ".", "Index", "(", ")", ")", "return", "self" ]

[ "Add", "a", "path", "based", "resolver", "for", "the", "given", "tag", ".", "A", "path", "is", "a", "list", "of", "keys", "that", "forms", "a", "path", "to", "a", "node", "in", "the", "representation", "tree", ".", "Keys", "can", "be", "string", "values", "integers", "or", "None", "." ]

[ "def", "add_path_resolver", "(", "tag", ",", "path", ",", "kind", "=", "None", ",", "Loader", "=", "Loader", ",", "Dumper", "=", "Dumper", ")", ":", "Loader", ".", "add_path_resolver", "(", "tag", ",", "path", ",", "kind", ")", "Dumper", ".", "add_path_resolver", "(", "tag", ",", "path", ",", "kind", ")" ]

[ "Returns", "the", "list", "of", "all", "events", "accepted", "by", "the", "indicated", "object", "." ]

[ "def", "getAllAccepting", "(", "self", ",", "object", ")", ":", "self", ".", "lock", ".", "acquire", "(", ")", "try", ":", "id", "=", "self", ".", "_getMessengerId", "(", "object", ")", "# Get the list of events this object is listening to", "eventDict", "=", "self", ".", "__objectEvents", ".", "get", "(", "id", ")", "if", "eventDict", ":", "return", "list", "(", "eventDict", ".", "keys", "(", ")", ")", "return", "[", "]", "finally", ":", "self", ".", "lock", ".", "release", "(", ")" ]

[ "Deserializes", "arbitrary", "Keras", "config", "using", "deserialize_fn", "." ]

[ "def", "_deserialize_nested_config", "(", "deserialize_fn", ",", "config", ")", ":", "def", "_is_single_object", "(", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "dict", ")", "and", "'class_name'", "in", "obj", ":", "return", "True", "# Serialized Keras object.", "if", "isinstance", "(", "obj", ",", "str", ")", ":", "return", "True", "# Serialized function or string.", "return", "False", "if", "config", "is", "None", ":", "return", "None", "if", "_is_single_object", "(", "config", ")", ":", "return", "deserialize_fn", "(", "config", ")", "elif", "isinstance", "(", "config", ",", "dict", ")", ":", "return", "{", "k", ":", "_deserialize_nested_config", "(", "deserialize_fn", ",", "v", ")", "for", "k", ",", "v", "in", "config", ".", "items", "(", ")", "}", "elif", "isinstance", "(", "config", ",", "(", "tuple", ",", "list", ")", ")", ":", "return", "[", "_deserialize_nested_config", "(", "deserialize_fn", ",", "obj", ")", "for", "obj", "in", "config", "]", "raise", "ValueError", "(", "'Saved configuration not understood.'", ")" ]

[ "IsOk", "(", "self", ")", "-", ">", "bool" ]

[ "def", "IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "Display_IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Compile", "src", "to", "product", "obj", "." ]

[ "def", "_compile", "(", "self", ",", "obj", ",", "src", ",", "ext", ",", "cc_args", ",", "extra_postargs", ",", "pp_opts", ")", ":", "# A concrete compiler class that does not override compile()", "# should implement _compile().", "pass" ]

[ "makeCutout", "(", "name", ")", ":", "makes", "an", "Cutout", "object", "." ]

[ "def", "makeCutout", "(", "name", ")", ":", "obj", "=", "FreeCAD", ".", "ActiveDocument", ".", "addObject", "(", "\"Part::FeaturePython\"", ",", "name", ")", "FeatureCutout", "(", "obj", ")", "if", "FreeCAD", ".", "GuiUp", ":", "ViewProviderCutout", "(", "obj", ".", "ViewObject", ")", "return", "obj" ]

[ "Returns", "true", "if", "connected", "to", "the", "server", "." ]

[ "def", "is_connected", "(", ")", ":", "if", "(", "__CLIENT__", "is", "not", "None", "and", "__SERVER__", "is", "not", "None", ")", ":", "# both client and server are live", "return", "True", "elif", "(", "__CLIENT__", "is", "None", "and", "__SERVER__", "is", "None", ")", ":", "# both client and server are dead", "return", "False", "else", ":", "# unlikely state: one of them are live and the other dead", "raise", "RuntimeError", "(", "'GraphLab connection error.'", ")" ]

[ "Parses", "the", "plugin", "arguments" ]

[ "def", "parse_plugin_definition", "(", "self", ",", "plugindef", ")", ":", "bareosfd", ".", "DebugMessage", "(", "100", ",", "\"parse_plugin_definition() was called in module %s\\n\"", "%", "(", "__name__", ")", ",", ")", "super", "(", "BareosFdPluginVMware", ",", "self", ")", ".", "parse_plugin_definition", "(", "plugindef", ")", "# if the option config_file is present, parse the given file", "config_file", "=", "self", ".", "options", ".", "get", "(", "\"config_file\"", ")", "if", "config_file", ":", "if", "not", "self", ".", "parse_config_file", "(", ")", ":", "return", "bareosfd", ".", "bRC_Error", "self", ".", "vadp", ".", "options", "=", "self", ".", "options", "return", "bareosfd", ".", "bRC_OK" ]

[ "Draw", "shape", "via", "rasterization", ".", "Used", "as", "a", "default", "draw", "method", ".", "Can", "and", "should", "be", "overwritten", "in", "child", "classes", "to", "implement", "a", "better", "draw", "method", "." ]

[ "def", "draw", "(", "self", ")", ":", "# get and store points of rasterized surface if not already present", "if", "self", ".", "rasterized_surface_points", "is", "None", ":", "self", ".", "rasterized_surface_points", "=", "self", ".", "_rasterize_shape", "(", ")", "set_solid_material", "(", "self", ".", "color", ",", "self", ".", "material", ")", "OpenGL", ".", "GL", ".", "glPointSize", "(", "self", ".", "pointsize", ")", "OpenGL", ".", "GL", ".", "glBegin", "(", "OpenGL", ".", "GL", ".", "GL_POINTS", ")", "for", "point", "in", "self", ".", "rasterized_surface_points", ":", "OpenGL", ".", "GL", ".", "glVertex3f", "(", "point", "[", "0", "]", ",", "point", "[", "1", "]", ",", "point", "[", "2", "]", ")", "OpenGL", ".", "GL", ".", "glEnd", "(", ")" ]

[ "Requests", "modal", "mouse", "input", "focus", ".", "When", "a", "widget", "has", "modal", "input", "focus", "that", "widget", "will", "be", "the", "only", "widget", "receiving", "input", "even", "if", "the", "input", "occurs", "outside", "of", "the", "widget", "and", "no", "matter", "what", "the", "input", "is", ".", "The", "widget", "must", "be", "modal", "mouse", "input", "focusable", "in", "order", "for", "this", "to", "work", ".", "Therefore", "no", "other", "widget", "should", "has", "modal", "input", "focus", "." ]

[ "def", "requestModalMouseInputFocus", "(", "self", ")", ":", "if", "self", ".", "isVisible", "(", ")", ":", "if", "self", ".", "isModalMouseInputFocusable", "(", ")", ":", "self", ".", "real_widget", ".", "requestModalMouseInputFocus", "(", ")" ]

[ "Does", "line", "terminate", "so", "that", "the", "next", "symbol", "is", "in", "string", "constant", "." ]

[ "def", "IsCppString", "(", "line", ")", ":", "line", "=", "line", ".", "replace", "(", "r'\\\\'", ",", "'XX'", ")", "# after this, \\\\\" does not match to \\\"", "return", "(", "(", "line", ".", "count", "(", "'\"'", ")", "-", "line", ".", "count", "(", "r'\\\"'", ")", "-", "line", ".", "count", "(", "\"'\\\"'\"", ")", ")", "&", "1", ")", "==", "1" ]

[ ":", "Parameters", ":", "-", "arg", "-", "another", "SVM", "object", "or", "a", "kernel", "object", ";", "if", "no", "argument", "is", "given", "the", "kernel", "function", "of", "the", "training", "dataset", "is", "used", ":", "Keywords", ":", "-", "C", "-", "the", "svm", "C", "parameter", "-", "Cmode", "-", "the", "way", "the", "C", "parameter", "is", "used", ";", "values", ":", "equal", "classProb", "fromData", ".", "In", "equal", "mode", "C", "is", "set", "to", "be", "the", "same", "for", "both", "classes", "In", "classProb", "mode", "each", "class", "is", "assigned", "a", "C", "value", "that", "is", "proportional", "to", "the", "size", "of", "the", "other", "class", ".", "This", "results", "in", "margin", "error", "costs", "being", "proportional", "to", "the", "ratio", "of", "the", "sizes", "of", "the", "two", "classes", ".", "This", "is", "useful", "for", "datasets", "with", "an", "unbalanced", "class", "distribution", ".", "In", "fromData", "the", "value", "of", "C", "for", "each", "pattern", "is", "taken", "from", "the", "C", "attribute", "of", "the", "training", "data", ".", "-", "optimizer", "-", "which", "optimizer", "to", "use", ".", "the", "options", "are", ":", "libsvm", "--", "run", "libsvm", "liblinear", "--", "use", "liblinear", "(", "linear", "svm", "only", ")", "in", "this", "case", "you", "have", "the", "option", "to", "set", "the", "loss", "function", "-", "either", "l1", "or", "l2", "mysmo", "-", "use", "the", "PyML", "native", "optmizer", "(", "based", "on", "libsvm", ")", "gist", "-", "use", "a", "gist", "-", "like", "optimizer", ".", "-", "loss", "-", "when", "using", "liblinear", "set", "this", "to", "l1", "or", "l2", "(", "default", ":", "l1", ")", "-", "cacheSize", "-", "size", "of", "the", "kernel", "cache", "(", "in", "MB", ")", "." ]

[ "def", "__init__", "(", "self", ",", "arg", "=", "None", ",", "*", "*", "args", ")", ":", "Classifier", ".", "__init__", "(", "self", ",", "arg", ",", "*", "*", "args", ")", "self", ".", "kernel", "=", "None", "if", "arg", ".", "__class__", "==", "self", ".", "__class__", ":", "if", "arg", ".", "kernel", "is", "not", "None", ":", "self", ".", "kernel", "=", "arg", ".", "kernel", ".", "__class__", "(", "arg", ".", "kernel", ")", "elif", "hasattr", "(", "arg", ",", "'type'", ")", "and", "arg", ".", "type", "==", "'kernel'", ":", "self", ".", "kernel", "=", "arg", ".", "__class__", "(", "arg", ")", "elif", "arg", "is", "not", "None", ":", "raise", "ValueError", ",", "'unknown type of argument'" ]

[ "Sets", "dependencies", "in", "the", "environment", "." ]

[ "def", "_SetDependencies", "(", "env", ",", "base_dir", ",", "res_file", ",", "rc_alls", ",", "translated_files", ",", "static_files", ")", ":", "if", "res_file", ":", "env", ".", "Depends", "(", "os", ".", "path", ".", "join", "(", "base_dir", ",", "res_file", ")", ",", "static_files", ")", "else", ":", "# Make a best effort dependency setup when no res file is specified.", "translated_files", ".", "extend", "(", "static_files", ")", "for", "rc_all", "in", "rc_alls", ":", "env", ".", "Depends", "(", "rc_all", ",", "translated_files", ")" ]

[ "LoadObject", "(", "self", "Window", "parent", "String", "name", "String", "classname", ")", "-", ">", "Object" ]

[ "def", "LoadObject", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_xrc", ".", "XmlResource_LoadObject", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parameters", "----------", "values", ":", "arraylike" ]

[ "def", "_get_hashtable_algo", "(", "values", ")", ":", "values", ",", "_", "=", "_ensure_data", "(", "values", ")", "ndtype", "=", "_check_object_for_strings", "(", "values", ")", "htable", "=", "_hashtables", "[", "ndtype", "]", "return", "htable", ",", "values" ]

[ "Merge", "multiple", "blob", "data", "whose", "type", "is", "bytes", "or", "ndarray" ]

[ "def", "_merge_blob", "(", "self", ",", "blob_data", ")", ":", "if", "len", "(", "blob_data", ")", "==", "1", ":", "values", "=", "[", "v", "for", "v", "in", "blob_data", ".", "values", "(", ")", "]", "return", "bytes", "(", "values", "[", "0", "]", ")", "# convert int to bytes", "def", "int_to_bytes", "(", "x", ":", "int", ")", "->", "bytes", ":", "return", "x", ".", "to_bytes", "(", "8", ",", "'big'", ")", "merged", "=", "bytes", "(", ")", "for", "field", ",", "v", "in", "blob_data", ".", "items", "(", ")", ":", "# convert ndarray to bytes", "if", "isinstance", "(", "v", ",", "np", ".", "ndarray", ")", ":", "v", "=", "v", ".", "astype", "(", "self", ".", "_header", ".", "schema", "[", "field", "]", "[", "\"type\"", "]", ")", ".", "tobytes", "(", ")", "merged", "+=", "int_to_bytes", "(", "len", "(", "v", ")", ")", "merged", "+=", "v", "return", "merged" ]

[ "Return", "widget", "to", "edit", "numeric", "value", "of", "attribute", "This", "is", "effectively", "the", "parametrisation", "of", "the", "masked", ".", "NumCtrl", "widget", "." ]

[ "def", "get_valuewidget_write", "(", "self", ")", ":", "# print 'get_numeditwidget',value", "widget", "=", "wx", ".", "CheckBox", "(", "self", ".", "parent", ",", "-", "1", ")", "if", "self", ".", "immediate_apply", ":", "self", ".", "parent", ".", "Bind", "(", "wx", ".", "EVT_CHECKBOX", ",", "self", ".", "on_apply_immediate", ",", "widget", ")", "value", "=", "self", ".", "get_value_obj", "(", ")", "widget", ".", "SetValue", "(", "value", ")", "return", "widget" ]

[ "r", "Sends", "a", "HEAD", "request", "." ]

[ "def", "head", "(", "url", ",", "*", "*", "kwargs", ")", ":", "kwargs", ".", "setdefault", "(", "'allow_redirects'", ",", "False", ")", "return", "request", "(", "'head'", ",", "url", ",", "*", "*", "kwargs", ")" ]

[ "Add", "training", "ops", "to", "the", "graph", "." ]

[ "def", "_train_ops", "(", "self", ",", "features", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "\"model\"", ")", ":", "model_outputs", "=", "self", ".", "state_manager", ".", "define_loss", "(", "self", ".", "model", ",", "features", ",", "estimator_lib", ".", "ModeKeys", ".", "TRAIN", ")", "train_op", "=", "optimizers", ".", "optimize_loss", "(", "model_outputs", ".", "loss", ",", "global_step", "=", "variables", ".", "get_global_step", "(", ")", ",", "optimizer", "=", "self", ".", "optimizer", ",", "# Learning rate is set in the Optimizer object", "learning_rate", "=", "None", ")", "return", "estimator_lib", ".", "EstimatorSpec", "(", "loss", "=", "model_outputs", ".", "loss", ",", "mode", "=", "estimator_lib", ".", "ModeKeys", ".", "TRAIN", ",", "train_op", "=", "train_op", ")" ]

[ "Shape", "for", "the", "mode", "/", "mean", "Tensors", "." ]

[ "def", "_mode_mean_shape", "(", "self", ")", ":", "shape", "=", "self", ".", "batch_shape", ".", "concatenate", "(", "self", ".", "event_shape", ")", "has_static_shape", "=", "shape", ".", "is_fully_defined", "(", ")", "if", "not", "has_static_shape", ":", "shape", "=", "array_ops", ".", "concat", "(", "[", "self", ".", "batch_shape_tensor", "(", ")", ",", "self", ".", "event_shape_tensor", "(", ")", ",", "]", ",", "0", ")", "return", "shape" ]

[ "Parameters", ":", "-", "num1", "-", "filename" ]

[ "def", "saveSet", "(", "self", ",", "num1", ",", "filename", ")", ":", "pass" ]

[ "Don", "t", "write", "." ]

[ "def", "write", "(", "self", ",", "x", ")", ":" ]

[ "Compile", "a", "node", "or", "template", "source", "code", ".", "The", "name", "parameter", "is", "the", "load", "name", "of", "the", "template", "after", "it", "was", "joined", "using", ":", "meth", ":", "join_path", "if", "necessary", "not", "the", "filename", "on", "the", "file", "system", ".", "the", "filename", "parameter", "is", "the", "estimated", "filename", "of", "the", "template", "on", "the", "file", "system", ".", "If", "the", "template", "came", "from", "a", "database", "or", "memory", "this", "can", "be", "omitted", "." ]

[ "def", "compile", "(", "self", ",", "source", ",", "name", "=", "None", ",", "filename", "=", "None", ",", "raw", "=", "False", ",", "defer_init", "=", "False", ")", ":", "source_hint", "=", "None", "try", ":", "if", "isinstance", "(", "source", ",", "basestring", ")", ":", "source_hint", "=", "source", "source", "=", "self", ".", "_parse", "(", "source", ",", "name", ",", "filename", ")", "if", "self", ".", "optimized", ":", "source", "=", "optimize", "(", "source", ",", "self", ")", "source", "=", "self", ".", "_generate", "(", "source", ",", "name", ",", "filename", ",", "defer_init", "=", "defer_init", ")", "if", "raw", ":", "return", "source", "if", "filename", "is", "None", ":", "filename", "=", "'<template>'", "else", ":", "filename", "=", "_encode_filename", "(", "filename", ")", "return", "self", ".", "_compile", "(", "source", ",", "filename", ")", "except", "TemplateSyntaxError", ":", "exc_info", "=", "sys", ".", "exc_info", "(", ")", "self", ".", "handle_exception", "(", "exc_info", ",", "source_hint", "=", "source", ")" ]

[ "Reload", "the", "module", "object", "re", "-", "parsing", "and", "re", "-", "initializing", "it", "." ]

[ "def", "s_reload", "(", "self", ",", "*", "args", ")", ":", "return", "self", ".", "s_apply", "(", "self", ".", "r_reload", ",", "args", ")" ]

[ "Ensures", "that", "all", "required", "elements", "of", "meta", "-", "data", "are", "supplied", "." ]

[ "def", "check_metadata", "(", "self", ")", ":", "metadata", "=", "self", ".", "distribution", ".", "metadata", "missing", "=", "[", "]", "for", "attr", "in", "(", "'name'", ",", "'version'", ",", "'url'", ")", ":", "if", "not", "(", "hasattr", "(", "metadata", ",", "attr", ")", "and", "getattr", "(", "metadata", ",", "attr", ")", ")", ":", "missing", ".", "append", "(", "attr", ")", "if", "missing", ":", "self", ".", "warn", "(", "\"missing required meta-data: %s\"", "%", "', '", ".", "join", "(", "missing", ")", ")", "if", "metadata", ".", "author", ":", "if", "not", "metadata", ".", "author_email", ":", "self", ".", "warn", "(", "\"missing meta-data: if 'author' supplied, \"", "+", "\"'author_email' must be supplied too\"", ")", "elif", "metadata", ".", "maintainer", ":", "if", "not", "metadata", ".", "maintainer_email", ":", "self", ".", "warn", "(", "\"missing meta-data: if 'maintainer' supplied, \"", "+", "\"'maintainer_email' must be supplied too\"", ")", "else", ":", "self", ".", "warn", "(", "\"missing meta-data: either (author and author_email) \"", "+", "\"or (maintainer and maintainer_email) \"", "+", "\"must be supplied\"", ")" ]

[ "Open", "a", "persistent", "dictionary", "for", "reading", "and", "writing", "." ]

[ "def", "open", "(", "filename", ",", "flag", "=", "'c'", ",", "protocol", "=", "None", ",", "writeback", "=", "False", ")", ":", "return", "DbfilenameShelf", "(", "filename", ",", "flag", ",", "protocol", ",", "writeback", ")" ]

[ "Does", "character", "substitution", "on", "a", "string", "and", "returns", "the", "html", "equivalent", "of", "the", "given", "string", ".", "@param", "text", ":", "text", "to", "transform", "@return", ":", "text", "with", "all", "special", "characters", "transformed" ]

[ "def", "TransformText", "(", "self", ",", "text", ")", ":", "text", "=", "text", ".", "replace", "(", "'&'", ",", "\"&amp;\"", ")", "# Ampersands", "text", "=", "text", ".", "replace", "(", "'<'", ",", "\"&lt;\"", ")", "# Less Than Symbols", "text", "=", "text", ".", "replace", "(", "'>'", ",", "\"&gt;\"", ")", "# Greater Than Symbols", "text", "=", "text", ".", "replace", "(", "\"\\\"\"", ",", "\"&quot;\"", ")", "return", "text" ]

[ "GetExtension", "(", "self", ")", "-", ">", "String" ]

[ "def", "GetExtension", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "ImageHandler_GetExtension", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Makes", "a", "TFLiteConverter", "object", "based", "on", "the", "flags", "provided", "." ]

[ "def", "_get_tflite_converter", "(", "flags", ")", ":", "# Parse input and output arrays.", "input_arrays", "=", "_parse_array", "(", "flags", ".", "input_arrays", ")", "input_shapes", "=", "None", "if", "flags", ".", "input_shapes", ":", "input_shapes_list", "=", "[", "_parse_array", "(", "shape", ",", "type_fn", "=", "int", ")", "for", "shape", "in", "six", ".", "ensure_str", "(", "flags", ".", "input_shapes", ")", ".", "split", "(", "\":\"", ")", "]", "input_shapes", "=", "dict", "(", "list", "(", "zip", "(", "input_arrays", ",", "input_shapes_list", ")", ")", ")", "output_arrays", "=", "_parse_array", "(", "flags", ".", "output_arrays", ")", "converter_kwargs", "=", "{", "\"input_arrays\"", ":", "input_arrays", ",", "\"input_shapes\"", ":", "input_shapes", ",", "\"output_arrays\"", ":", "output_arrays", "}", "# Create TFLiteConverter.", "if", "flags", ".", "graph_def_file", ":", "converter_fn", "=", "lite", ".", "TFLiteConverter", ".", "from_frozen_graph", "converter_kwargs", "[", "\"graph_def_file\"", "]", "=", "flags", ".", "graph_def_file", "elif", "flags", ".", "saved_model_dir", ":", "converter_fn", "=", "lite", ".", "TFLiteConverter", ".", "from_saved_model", "converter_kwargs", "[", "\"saved_model_dir\"", "]", "=", "flags", ".", "saved_model_dir", "converter_kwargs", "[", "\"tag_set\"", "]", "=", "_parse_set", "(", "flags", ".", "saved_model_tag_set", ")", "converter_kwargs", "[", "\"signature_key\"", "]", "=", "flags", ".", "saved_model_signature_key", "elif", "flags", ".", "keras_model_file", ":", "converter_fn", "=", "lite", ".", "TFLiteConverter", ".", "from_keras_model_file", "converter_kwargs", "[", "\"model_file\"", "]", "=", "flags", ".", "keras_model_file", "else", ":", "raise", "ValueError", "(", "\"--graph_def_file, --saved_model_dir, or \"", "\"--keras_model_file must be specified.\"", ")", "return", "converter_fn", "(", "*", "*", "converter_kwargs", ")" ]

[ "Get", "the", "Subject", "s", "Common", "Name", "from", "the", "certificate", "." ]

[ "def", "getCommonName", "(", "self", ")", ":", "import", "cryptlib_py", "import", "array", "c", "=", "cryptlib_py", ".", "cryptImportCert", "(", "self", ".", "bytes", ",", "cryptlib_py", ".", "CRYPT_UNUSED", ")", "name", "=", "cryptlib_py", ".", "CRYPT_CERTINFO_COMMONNAME", "try", ":", "try", ":", "length", "=", "cryptlib_py", ".", "cryptGetAttributeString", "(", "c", ",", "name", ",", "None", ")", "returnVal", "=", "array", ".", "array", "(", "'B'", ",", "[", "0", "]", "*", "length", ")", "cryptlib_py", ".", "cryptGetAttributeString", "(", "c", ",", "name", ",", "returnVal", ")", "returnVal", "=", "returnVal", ".", "tostring", "(", ")", "except", "cryptlib_py", ".", "CryptException", ",", "e", ":", "if", "e", "[", "0", "]", "==", "cryptlib_py", ".", "CRYPT_ERROR_NOTFOUND", ":", "returnVal", "=", "None", "return", "returnVal", "finally", ":", "cryptlib_py", ".", "cryptDestroyCert", "(", "c", ")" ]

[ "Update", "current", "cursor", "window", "coordinates", "." ]

[ "def", "drag", "(", "self", ",", "point", ")", ":", "vnow", "=", "arcball_map_to_sphere", "(", "point", ",", "self", ".", "_center", ",", "self", ".", "_radius", ")", "if", "self", ".", "_axis", "is", "not", "None", ":", "vnow", "=", "arcball_constrain_to_axis", "(", "vnow", ",", "self", ".", "_axis", ")", "self", ".", "_qpre", "=", "self", ".", "_qnow", "t", "=", "numpy", ".", "cross", "(", "self", ".", "_vdown", ",", "vnow", ")", "if", "numpy", ".", "dot", "(", "t", ",", "t", ")", "<", "_EPS", ":", "self", ".", "_qnow", "=", "self", ".", "_qdown", "else", ":", "q", "=", "[", "t", "[", "0", "]", ",", "t", "[", "1", "]", ",", "t", "[", "2", "]", ",", "numpy", ".", "dot", "(", "self", ".", "_vdown", ",", "vnow", ")", "]", "self", ".", "_qnow", "=", "quaternion_multiply", "(", "q", ",", "self", ".", "_qdown", ")" ]

[ "Subclasses", "have", "to", "override", "this", "method", "to", "write", "the", "bytecode", "from", "a", "bucket", "back", "to", "the", "cache", ".", "If", "it", "unable", "to", "do", "so", "it", "must", "not", "fail", "silently", "but", "raise", "an", "exception", "." ]

[ "def", "dump_bytecode", "(", "self", ",", "bucket", ")", ":", "raise", "NotImplementedError", "(", ")" ]

[ "Constructs", "the", "stub", "class", "." ]

[ "def", "BuildServiceStub", "(", "self", ",", "cls", ")", ":", "def", "_ServiceStubInit", "(", "stub", ",", "rpc_channel", ")", ":", "stub", ".", "rpc_channel", "=", "rpc_channel", "self", ".", "cls", "=", "cls", "cls", ".", "__init__", "=", "_ServiceStubInit", "for", "method", "in", "self", ".", "descriptor", ".", "methods", ":", "setattr", "(", "cls", ",", "method", ".", "name", ",", "self", ".", "_GenerateStubMethod", "(", "method", ")", ")" ]

[ "Read", "in", "docstrings", "from", "lang", "-", "specific", "docstring", "dictionary", "." ]

[ "def", "read_docstrings", "(", "lang", ")", ":", "modname", "=", "\"turtle_docstringdict_%(language)s\"", "%", "{", "'language'", ":", "lang", ".", "lower", "(", ")", "}", "module", "=", "__import__", "(", "modname", ")", "docsdict", "=", "module", ".", "docsdict", "for", "key", "in", "docsdict", ":", "try", ":", "# eval(key).im_func.__doc__ = docsdict[key]", "eval", "(", "key", ")", ".", "__doc__", "=", "docsdict", "[", "key", "]", "except", "Exception", ":", "print", "(", "\"Bad docstring-entry: %s\"", "%", "key", ")" ]

[ "Run", "the", "stats", "counter", "." ]

[ "def", "Main", "(", "data_file", ",", "name_filter", ")", ":", "StatsViewer", "(", "data_file", ",", "name_filter", ")", ".", "Run", "(", ")" ]

[ "Applies", "natural", "exponential", "decay", "to", "the", "initial", "learning", "rate", "." ]

[ "def", "natural_exp_decay", "(", "learning_rate", ",", "global_step", ",", "decay_steps", ",", "decay_rate", ",", "staircase", "=", "False", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "learning_rate", ",", "global_step", ",", "decay_rate", "]", ",", "name", ",", "\"NaturalExpDecay\"", ")", "as", "name", ":", "learning_rate", "=", "ops", ".", "convert_to_tensor", "(", "learning_rate", ",", "name", "=", "\"learning_rate\"", ")", "dtype", "=", "learning_rate", ".", "dtype", "global_step", "=", "math_ops", ".", "cast", "(", "global_step", ",", "dtype", ")", "decay_steps", "=", "math_ops", ".", "cast", "(", "decay_steps", ",", "dtype", ")", "decay_rate", "=", "math_ops", ".", "cast", "(", "decay_rate", ",", "dtype", ")", "p", "=", "global_step", "/", "decay_steps", "if", "staircase", ":", "p", "=", "math_ops", ".", "floor", "(", "p", ")", "exponent", "=", "math_ops", ".", "exp", "(", "math_ops", ".", "mul", "(", "math_ops", ".", "neg", "(", "decay_rate", ")", ",", "p", ")", ")", "return", "math_ops", ".", "mul", "(", "learning_rate", ",", "exponent", ",", "name", "=", "name", ")" ]

[ "GetPlaygroundTransformEnabled", "(", "self", ")", "-", ">", "bool" ]

[ "def", "GetPlaygroundTransformEnabled", "(", "self", ")", ":", "return", "_lldb", ".", "SBExpressionOptions_GetPlaygroundTransformEnabled", "(", "self", ")" ]

[ "Request", "a", "status", "of", "a", "transaction", ":", "param", "transaction", ":", "the", "transaction", "which", "status", "is", "about", "to", "be", "known", ":", "return", ":", "a", "tuple", "with", "the", "symbolic", "status", "description", "integral", "status", "code", "and", "error", "message", "string", "(", "will", "be", "empty", "if", "no", "error", "occurred", ")" ]

[ "def", "tx_status", "(", "self", ",", "transaction", ")", ":", "request", "=", "endpoint_pb2", ".", "TxStatusRequest", "(", ")", "request", ".", "tx_hash", "=", "binascii", ".", "hexlify", "(", "IrohaCrypto", ".", "hash", "(", "transaction", ")", ")", "response", "=", "self", ".", "_command_service_stub", ".", "Status", "(", "request", ")", "status_code", "=", "response", ".", "tx_status", "status_name", "=", "endpoint_pb2", ".", "TxStatus", ".", "Name", "(", "response", ".", "tx_status", ")", "error_message", "=", "response", ".", "error_message", "return", "status_name", ",", "status_code", ",", "error_message" ]

[ "capture", "(", "command", ")", "-", "Run", "the", "given", "command", "(", "or", "argv", "list", ")", "in", "a", "shell", "and", "return", "the", "standard", "output", ".", "Raises", "a", "CalledProcessError", "if", "the", "command", "exits", "with", "a", "non", "-", "zero", "status", "." ]

[ "def", "capture", "(", "args", ",", "env", "=", "None", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "args", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "env", "=", "env", ")", "out", ",", "err", "=", "p", ".", "communicate", "(", ")", "out", "=", "convert_string", "(", "out", ")", "err", "=", "convert_string", "(", "err", ")", "if", "p", ".", "returncode", "!=", "0", ":", "raise", "subprocess", ".", "CalledProcessError", "(", "cmd", "=", "args", ",", "returncode", "=", "p", ".", "returncode", ",", "output", "=", "\"{}\\n{}\"", ".", "format", "(", "out", ",", "err", ")", ")", "return", "out" ]

[ "Counts", "the", "number", "of", "warnings", "that", "occurs", "." ]

[ "def", "warn", "(", "self", ",", "msg", ")", ":", "self", ".", "_warnings", "+=", "1", "return", "Command", ".", "warn", "(", "self", ",", "msg", ")" ]

[ "Add", "embedding", "variable", "name", "and", "scope", "to", "collection", "." ]

[ "def", "_record_variable_scope_and_name", "(", "embedding_var_name", ",", "embedding_var_name_in_fc", ",", "is_shared_embedding", "=", "False", ")", ":", "g", "=", "ops", ".", "get_default_graph", "(", ")", "collection", "=", "g", ".", "get_collection_ref", "(", "_TPU_FC_TO_SCOPE", ")", "if", "not", "collection", ":", "collection", ".", "append", "(", "{", "}", ")", "var_def_dict", "=", "collection", "[", "0", "]", "captured_scope", "=", "variable_scope", ".", "get_variable_scope", "(", ")", "captured_scope_name", "=", "captured_scope", ".", "name", "if", "embedding_var_name", "in", "var_def_dict", ":", "if", "(", "var_def_dict", "[", "embedding_var_name", "]", "[", "0", "]", "!=", "captured_scope_name", "and", "not", "is_shared_embedding", ")", ":", "raise", "ValueError", "(", "'For embedding var name {}, the variable scope name is different, '", "'got {}; expected {}'", ".", "format", "(", "embedding_var_name", ",", "captured_scope_name", ",", "var_def_dict", "[", "embedding_var_name", "]", "[", "0", "]", ")", ")", "if", "var_def_dict", "[", "embedding_var_name", "]", "[", "1", "]", "!=", "embedding_var_name_in_fc", ":", "raise", "ValueError", "(", "'For embedding var name {}, the embedding name is different, '", "'got {}; expected {}'", ".", "format", "(", "embedding_var_name", ",", "embedding_var_name_in_fc", ",", "var_def_dict", "[", "embedding_var_name", "]", "[", "1", "]", ")", ")", "else", ":", "var_def_dict", "[", "embedding_var_name", "]", "=", "(", "captured_scope_name", ",", "embedding_var_name_in_fc", ")" ]

[ "This", "function", "calls", "all", "needed", "steps", "for", "running", "the", "analysis", "." ]

[ "def", "run_analysis", "(", "self", ")", ":", "super", "(", "GeneSetAnalysis", ",", "self", ")", ".", "run_analysis", "(", ")", "# validate sequence file", "if", "super", "(", "GeneSetAnalysis", ",", "self", ")", ".", "check_protein_file", "(", ")", "is", "False", ":", "GeneSetAnalysis", ".", "_logger", ".", "error", "(", "'Please provide a protein file as input'", ")", "raise", "SystemExit", "self", ".", "_load_score", "(", ")", "self", ".", "_load_length", "(", ")", "self", ".", "_run_hmmer", "(", ")", "self", ".", "_produce_short_summary", "(", ")", "self", ".", "cleanup", "(", ")", "if", "self", ".", "_tarzip", ":", "self", ".", "_run_tarzip_hmmer_output", "(", ")" ]

[ "Filter", "out", "files", "from", "dir", "/", "." ]

[ "def", "prune", "(", "self", ",", "dir", ")", ":", "match", "=", "translate_pattern", "(", "os", ".", "path", ".", "join", "(", "dir", ",", "'**'", ")", ")", "return", "self", ".", "_remove_files", "(", "match", ".", "match", ")" ]

[ "Debug", "helper", "that", "prints", "the", "signature", "of", "a", "Function", "." ]

[ "def", "dump_signature", "(", "root", ",", "tag", "=", "None", ")", ":", "print", "(", "str", "(", "root", ")", ")" ]

[ "Adds", "CXXFLAGS", "/", "CPPFLAGS", "from", "os", ".", "environ", "to", "conf", ".", "env" ]

[ "def", "cxx_add_flags", "(", "conf", ")", ":", "conf", ".", "add_os_flags", "(", "'CPPFLAGS'", ",", "dup", "=", "False", ")", "conf", ".", "add_os_flags", "(", "'CXXFLAGS'", ",", "dup", "=", "False", ")" ]

[ "Get", "the", "working", "directory", "for", "this", "CompileCommand" ]

[ "def", "directory", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_CompileCommand_getDirectory", "(", "self", ".", "cmd", ")" ]

[ "Return", "the", "snapshot", "statistics", "to", "the", "console", "." ]

[ "def", "report", "(", "self", ",", "sortby", "=", "'lineno'", ",", "cumulative", "=", "True", ",", "limit", "=", "100", ")", ":", "for", "stat", "in", "self", ".", "snapshot", ".", "statistics", "(", "sortby", ",", "cumulative", ")", "[", ":", "limit", "]", ":", "print", "(", "stat", ")" ]

[ "Compute", "the", "estimated", "size", "of", "the", "ops", ".", "outputs", "in", "the", "graph", "." ]

[ "def", "analyze_ops", "(", "graph", ",", "print_info", "=", "False", ")", ":", "if", "print_info", ":", "print", "(", "'---------'", ")", "print", "(", "'Operations: name -> (type shapes) [size]'", ")", "print", "(", "'---------'", ")", "total_size", "=", "0", "for", "op", "in", "graph", ".", "get_operations", "(", ")", ":", "op_size", "=", "0", "shapes", "=", "[", "]", "for", "output", "in", "op", ".", "outputs", ":", "# if output.num_elements() is None or [] assume size 0.", "output_size", "=", "output", ".", "get_shape", "(", ")", ".", "num_elements", "(", ")", "or", "0", "if", "output", ".", "get_shape", "(", ")", ":", "shapes", ".", "append", "(", "tensor_description", "(", "output", ")", ")", "op_size", "+=", "output_size", "if", "print_info", ":", "print", "(", "op", ".", "name", ",", "'\\t->'", ",", "', '", ".", "join", "(", "shapes", ")", ",", "'['", "+", "str", "(", "op_size", ")", "+", "']'", ")", "total_size", "+=", "op_size", "return", "total_size" ]

[ "Prevent", "objects", "from", "being", "dragged", "outside", "of", "viewable", "area" ]

[ "def", "OnMovePre", "(", "self", ",", "dc", ",", "x", ",", "y", ",", "oldX", ",", "oldY", ",", "display", ")", ":", "if", "(", "x", "<", "0", ")", "or", "(", "y", "<", "0", ")", "or", "(", "x", ">", "self", ".", "_view", ".", "_maxWidth", ")", "or", "(", "y", ">", "self", ".", "_view", ".", "_maxHeight", ")", ":", "return", "False", "return", "ogl", ".", "ShapeEvtHandler", ".", "OnMovePre", "(", "self", ",", "dc", ",", "x", ",", "y", ",", "oldX", ",", "oldY", ",", "display", ")" ]

[ "Insert", "a", "set", "of", "equivalent", "objects", "by", "modifying", "self", ".", "This", "method", "can", "be", "overloaded", "to", "transform", "object", "type", "before", "insertion", "." ]

[ "def", "insert_equiv", "(", "self", ",", "*", "objs", ")", ":", "return", "self", ".", "_insert", "(", "objs", ")" ]

[ "Compute", "the", "2", "-", "dimensional", "inverse", "FFT", "of", "a", "real", "array", "." ]

[ "def", "irfft2", "(", "a", ",", "s", "=", "None", ",", "axes", "=", "(", "-", "2", ",", "-", "1", ")", ",", "norm", "=", "None", ")", ":", "return", "irfftn", "(", "a", ",", "s", ",", "axes", ",", "norm", ")" ]

[ "HD", "Edition", "3", ".", "x", "and", "below", "store", "language", ".", "txt", "files", "in", "the", "Bin", "/", "folder", ".", "Specific", "language", "strings", "are", "in", "Bin", "/", "$LANG", "/", "*", ".", "txt", "." ]

[ "def", "read_age2_hd_3x_stringresources", "(", "stringres", ",", "srcdir", ")", ":", "count", "=", "0", "for", "lang", "in", "srcdir", "[", "\"bin\"", "]", ".", "list", "(", ")", ":", "lang_path", "=", "srcdir", "[", "\"bin\"", ",", "lang", ".", "decode", "(", ")", "]", "# There are some .txt files immediately in bin/, but they don't", "# seem to contain anything useful. (Everything is overridden by", "# files in Bin/$LANG/.)", "if", "not", "lang_path", ".", "is_dir", "(", ")", ":", "continue", "# Sometimes we can have language DLLs in Bin/$LANG/", "# e.g. HD Edition 2.0", "# We do _not_ want to treat these as text files", "# so first check explicitly", "if", "lang_path", "[", "\"language.dll\"", "]", ".", "is_file", "(", ")", ":", "for", "name", "in", "[", "\"language.dll\"", ",", "\"language_x1.dll\"", ",", "\"language_x1_p1.dll\"", "]", ":", "pefile", "=", "PEFile", "(", "lang_path", "[", "name", "]", ".", "open", "(", "'rb'", ")", ")", "stringres", ".", "fill_from", "(", "pefile", ".", "resources", "(", ")", ".", "strings", ")", "count", "+=", "1", "else", ":", "for", "basename", "in", "lang_path", ".", "list", "(", ")", ":", "with", "lang_path", "[", "basename", "]", ".", "open", "(", "'rb'", ")", "as", "langfile", ":", "# No utf-8 :(", "stringres", ".", "fill_from", "(", "read_hd_language_file_old", "(", "langfile", ",", "lang", ",", "enc", "=", "'iso-8859-1'", ")", ")", "count", "+=", "1", "return", "count" ]

[ "Read", "an", "array", "to", "get", "the", "decoded", "ids", "and", "scores", "generated", "by", "previous", "RNN", "step", ".", "At", "the", "first", "step", "of", "RNN", "the", "init", "variable", "mut", "be", "used", "to", "initialize", "the", "array", "." ]

[ "def", "read_array", "(", "self", ",", "init", ",", "is_ids", "=", "False", ",", "is_scores", "=", "False", ")", ":", "self", ".", "_assert_in_decoder_block", "(", "'read_array'", ")", "if", "is_ids", "and", "is_scores", ":", "raise", "ValueError", "(", "'Shouldn\\'t mark current array be ids array and'", "'scores array at the same time.'", ")", "if", "not", "isinstance", "(", "init", ",", "Variable", ")", ":", "raise", "TypeError", "(", "'The input argument `init` must be a Variable.'", ")", "parent_block", "=", "self", ".", "_parent_block", "(", ")", "array", "=", "parent_block", ".", "create_var", "(", "name", "=", "unique_name", ".", "generate", "(", "'beam_search_decoder_array'", ")", ",", "type", "=", "core", ".", "VarDesc", ".", "VarType", ".", "LOD_TENSOR_ARRAY", ",", "dtype", "=", "init", ".", "dtype", ")", "parent_block", ".", "append_op", "(", "type", "=", "'write_to_array'", ",", "inputs", "=", "{", "'X'", ":", "init", ",", "'I'", ":", "self", ".", "_zero_idx", "}", ",", "outputs", "=", "{", "'Out'", ":", "array", "}", ")", "if", "is_ids", ":", "self", ".", "_ids_array", "=", "array", "elif", "is_scores", ":", "self", ".", "_scores_array", "=", "array", "read_value", "=", "layers", ".", "array_read", "(", "array", "=", "array", ",", "i", "=", "self", ".", "_counter", ")", "self", ".", "_array_dict", "[", "read_value", ".", "name", "]", "=", "array", "return", "read_value" ]

[ "Set", "(", "self", "int", "day", "int", "month", "=", "Inv_Month", "int", "year", "=", "Inv_Year", "int", "hour", "=", "0", "int", "minute", "=", "0", "int", "second", "=", "0", "int", "millisec", "=", "0", ")", "-", ">", "DateTime" ]

[ "def", "Set", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DateTime_Set", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "a", "random", "value", "from", "[", "-", "offset", "offset", "]", "to", "each", "channel" ]

[ "def", "color_cast", "(", "self", ",", "offset", "=", "20", ",", "inplace", "=", "True", ")", ":", "new_imgs", "=", "[", "]", "if", "offset", "<", "0", "or", "offset", ">", "255", ":", "raise", "Exception", "(", "'offset must be >0 and <255'", ")", "for", "img", "in", "self", ".", "imgs", ":", "new_img", "=", "color_cast", "(", "img", ",", "offset", ")", "new_imgs", ".", "append", "(", "new_img", ")", "if", "inplace", ":", "self", ".", "imgs", "=", "new_imgs", "return", "self", "else", ":", "return", "new_imgs" ]

[ ":", "type", "version1", ":", "str", ":", "type", "version2", ":", "str", ":", "rtype", ":", "int" ]

[ "def", "compareVersion2", "(", "self", ",", "version1", ",", "version2", ")", ":", "v1", "=", "[", "int", "(", "x", ")", "for", "x", "in", "version1", ".", "split", "(", "'.'", ")", "]", "v2", "=", "[", "int", "(", "x", ")", "for", "x", "in", "version2", ".", "split", "(", "'.'", ")", "]", "while", "len", "(", "v1", ")", "!=", "len", "(", "v2", ")", ":", "if", "len", "(", "v1", ")", ">", "len", "(", "v2", ")", ":", "v2", ".", "append", "(", "0", ")", "else", ":", "v1", ".", "append", "(", "0", ")", "return", "cmp", "(", "v1", ",", "v2", ")" ]

[ "Convert", "the", "the", "MSVS", "macros", "found", "in", "the", "string", "to", "the", "MSBuild", "equivalent", "." ]

[ "def", "ConvertVCMacrosToMSBuild", "(", "s", ")", ":", "if", "'$'", "in", "s", ":", "replace_map", "=", "{", "'$(ConfigurationName)'", ":", "'$(Configuration)'", ",", "'$(InputDir)'", ":", "'%(RelativeDir)'", ",", "'$(InputExt)'", ":", "'%(Extension)'", ",", "'$(InputFileName)'", ":", "'%(Filename)%(Extension)'", ",", "'$(InputName)'", ":", "'%(Filename)'", ",", "'$(InputPath)'", ":", "'%(Identity)'", ",", "'$(ParentName)'", ":", "'$(ProjectFileName)'", ",", "'$(PlatformName)'", ":", "'$(Platform)'", ",", "'$(SafeInputName)'", ":", "'%(Filename)'", ",", "}", "for", "old", ",", "new", "in", "replace_map", ".", "iteritems", "(", ")", ":", "s", "=", "s", ".", "replace", "(", "old", ",", "new", ")", "s", "=", "FixVCMacroSlashes", "(", "s", ")", "return", "s" ]

[ "Make", "stream", "jump", "to", "a", "new", "location", "saving", "old", "location", ".", "Switch", "back", "with", "pop", "()", "." ]

[ "def", "push", "(", "self", ",", "index", ")", ":", "self", ".", "calls", ".", "append", "(", "self", ".", "p", ")", "# save current index", "self", ".", "seek", "(", "index", ")" ]

[ "Compute", "flops", "for", "L2Loss", "operation", "." ]

[ "def", "_l2_loss_flops", "(", "graph", ",", "node", ")", ":", "in_shape", "=", "graph_util", ".", "tensor_shape_from_node_def_name", "(", "graph", ",", "node", ".", "input", "[", "0", "]", ")", "in_shape", ".", "assert_is_fully_defined", "(", ")", "# Tensorflow uses inefficient implementation, with (3*N-1) flops:", "# Optimal implementation is 2*N flops", "return", "ops", ".", "OpStats", "(", "\"flops\"", ",", "in_shape", ".", "num_elements", "(", ")", "*", "3", "-", "1", ")" ]

[ "FileProperty_GetClassValidator", "()", "-", ">", "Validator" ]

[ "def", "FileProperty_GetClassValidator", "(", "*", "args", ")", ":", "return", "_propgrid", ".", "FileProperty_GetClassValidator", "(", "*", "args", ")" ]

[ "Overridden", "from", "TypeHandler", "." ]

[ "def", "WriteHandlerImplementation", "(", "self", ",", "func", ",", "file", ")", ":", "state_name", "=", "func", ".", "GetInfo", "(", "'state'", ")", "state", "=", "_STATES", "[", "state_name", "]", "states", "=", "state", "[", "'states'", "]", "args", "=", "func", ".", "GetOriginalArgs", "(", ")", "num_args", "=", "len", "(", "args", ")", "assert", "num_args", "==", "2", "file", ".", "Write", "(", "\" switch (%s) {\\n\"", "%", "args", "[", "0", "]", ".", "name", ")", "for", "state", "in", "states", ":", "file", ".", "Write", "(", "\" case %s:\\n\"", "%", "state", "[", "'enum'", "]", ")", "file", ".", "Write", "(", "\" if (state_.%s != %s) {\\n\"", "%", "(", "state", "[", "'name'", "]", ",", "args", "[", "1", "]", ".", "name", ")", ")", "file", ".", "Write", "(", "\" state_.%s = %s;\\n\"", "%", "(", "state", "[", "'name'", "]", ",", "args", "[", "1", "]", ".", "name", ")", ")", "if", "not", "func", ".", "GetInfo", "(", "\"no_gl\"", ")", ":", "file", ".", "Write", "(", "\" %s(%s);\\n\"", "%", "(", "func", ".", "GetGLFunctionName", "(", ")", ",", "func", ".", "MakeOriginalArgString", "(", "\"\"", ")", ")", ")", "file", ".", "Write", "(", "\" }\\n\"", ")", "file", ".", "Write", "(", "\" break;\\n\"", ")", "file", ".", "Write", "(", "\" default:\\n\"", ")", "file", ".", "Write", "(", "\" NOTREACHED();\\n\"", ")", "file", ".", "Write", "(", "\" }\\n\"", ")" ]

[ "Fetch", "the", "specified", "entry", "attribute", "." ]

[ "def", "get_entry", "(", "self", ",", "filename", ")", ":", "return", "self", ".", "entries", "[", "filename", "]" ]

[ "Returns", "a", "list", "of", "shopping", "carts", "in", "your", "Webstore", "that", "were", "last", "updated", "during", "the", "time", "range", "that", "you", "specify", "." ]

[ "def", "list_carts", "(", "self", ",", "request", ",", "response", ",", "*", "*", "kw", ")", ":", "return", "self", ".", "_post_request", "(", "request", ",", "kw", ",", "response", ")" ]

[ "Test", "if", "this", "is", "a", "preprocessing", "kind", "." ]

[ "def", "is_preprocessing", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_isPreprocessing", "(", "self", ")" ]

[ "SetHScrollBar", "(", "self", "ScrollBar", "bar", ")" ]

[ "def", "SetHScrollBar", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetHScrollBar", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Handle", "incoming", "data", "on", "socket", "." ]

[ "def", "_handle_incoming_data", "(", "self", ",", "conn", ")", ":", "connection", "=", "[", "c", "for", "c", "in", "self", ".", "connections", "if", "c", ".", "conn", "==", "conn", "]", "[", "0", "]", "data", "=", "conn", ".", "recv", "(", "1024", ")", "if", "data", ":", "connection", ".", "feed", "(", "data", ")", "else", ":", "self", ".", "connections", ".", "remove", "(", "connection", ")" ]

[ "Parse", "the", "229", "response", "for", "a", "EPSV", "request", ".", "Raises", "error_proto", "if", "it", "does", "not", "contain", "(", "|||port|", ")", "Return", "(", "host", ".", "addr", ".", "as", ".", "numbers", "port#", ")", "tuple", "." ]

[ "def", "parse229", "(", "resp", ",", "peer", ")", ":", "if", "resp", "[", ":", "3", "]", "!=", "'229'", ":", "raise", "error_reply", ",", "resp", "left", "=", "resp", ".", "find", "(", "'('", ")", "if", "left", "<", "0", ":", "raise", "error_proto", ",", "resp", "right", "=", "resp", ".", "find", "(", "')'", ",", "left", "+", "1", ")", "if", "right", "<", "0", ":", "raise", "error_proto", ",", "resp", "# should contain '(|||port|)'", "if", "resp", "[", "left", "+", "1", "]", "!=", "resp", "[", "right", "-", "1", "]", ":", "raise", "error_proto", ",", "resp", "parts", "=", "resp", "[", "left", "+", "1", ":", "right", "]", ".", "split", "(", "resp", "[", "left", "+", "1", "]", ")", "if", "len", "(", "parts", ")", "!=", "5", ":", "raise", "error_proto", ",", "resp", "host", "=", "peer", "[", "0", "]", "port", "=", "int", "(", "parts", "[", "3", "]", ")", "return", "host", ",", "port" ]

[ "r", "\\", "n" ]

[ "def", "t_ppline_NEWLINE", "(", "self", ",", "t", ")", ":", "if", "self", ".", "pp_line", "is", "None", ":", "self", ".", "_error", "(", "'line number missing in #line'", ",", "t", ")", "else", ":", "self", ".", "lexer", ".", "lineno", "=", "int", "(", "self", ".", "pp_line", ")", "if", "self", ".", "pp_filename", "is", "not", "None", ":", "self", ".", "filename", "=", "self", ".", "pp_filename", "t", ".", "lexer", ".", "begin", "(", "'INITIAL'", ")" ]

[ "Return", "true", "iff", "packable", "=", "true", "is", "valid", "for", "fields", "of", "this", "type", "." ]

[ "def", "IsTypePackable", "(", "field_type", ")", ":", "return", "field_type", "not", "in", "NON_PACKABLE_TYPES" ]

[ "Blocks", "until", "all", "items", "in", "the", "Queue", "have", "been", "gotten", "and", "processed", "." ]

[ "def", "join", "(", "self", ")", ":", "with", "self", ".", "all_tasks_done", ":", "while", "self", ".", "unfinished_tasks", ":", "self", ".", "all_tasks_done", ".", "wait", "(", ")" ]

[ "r", "Export", "multiple", "meshes", "to", "a", "new", "USD", "stage", "." ]

[ "def", "export_meshes", "(", "file_path", ",", "scene_paths", "=", "None", ",", "vertices", "=", "None", ",", "faces", "=", "None", ",", "uvs", "=", "None", ",", "face_uvs_idx", "=", "None", ",", "face_normals", "=", "None", ",", "materials_order", "=", "None", ",", "materials", "=", "None", ",", "up_axis", "=", "'Y'", ",", "times", "=", "None", ")", ":", "stage", "=", "create_stage", "(", "file_path", ",", "up_axis", ")", "mesh_parameters", "=", "{", "'vertices'", ":", "vertices", ",", "'faces'", ":", "faces", ",", "'uvs'", ":", "uvs", ",", "'face_uvs_idx'", ":", "face_uvs_idx", ",", "'face_normals'", ":", "face_normals", ",", "'materials_order'", ":", "materials_order", ",", "'materials'", ":", "materials", "}", "supplied_parameters", "=", "{", "k", ":", "p", "for", "k", ",", "p", "in", "mesh_parameters", ".", "items", "(", ")", "if", "p", "is", "not", "None", "}", "length", "=", "len", "(", "list", "(", "supplied_parameters", ".", "values", "(", ")", ")", "[", "0", "]", ")", "assert", "all", "(", "[", "len", "(", "p", ")", "==", "length", "for", "p", "in", "supplied_parameters", ".", "values", "(", ")", "]", ")", "if", "scene_paths", "is", "None", ":", "if", "not", "stage", ".", "GetPrimAtPath", "(", "'/World/Meshes'", ")", ":", "stage", ".", "DefinePrim", "(", "'/World/Meshes'", ",", "'Xform'", ")", "scene_paths", "=", "[", "f'/World/Meshes/mesh_{i}'", "for", "i", "in", "range", "(", "len", "(", "vertices", ")", ")", "]", "assert", "len", "(", "scene_paths", ")", "==", "length", "if", "times", "is", "None", ":", "times", "=", "[", "Usd", ".", "TimeCode", ".", "Default", "(", ")", "]", "*", "len", "(", "scene_paths", ")", "for", "i", ",", "scene_path", "in", "enumerate", "(", "scene_paths", ")", ":", "mesh_params", "=", "{", "k", ":", "p", "[", "i", "]", "for", "k", ",", "p", "in", "supplied_parameters", ".", "items", "(", ")", "}", "add_mesh", "(", "stage", ",", "scene_path", ",", "*", "*", "mesh_params", ")", "stage", ".", "Save", "(", ")", "return", "stage" ]

[ "mark", "a", "maze", "cell", "with", "the", "specified", "color" ]

[ "def", "mark_maze", "(", "self", ",", "r", ",", "c", ",", "marker", ")", ":", "# remove the previous object, if necessary", "if", "(", "r", ",", "c", ")", "in", "self", ".", "marker_map", ":", "removeObject", "(", "self", ".", "marker_map", "[", "(", "r", ",", "c", ")", "]", ")", "# remember the ID of the marker", "self", ".", "marker_map", "[", "(", "r", ",", "c", ")", "]", "=", "addObject", "(", "marker", ",", "Vector3f", "(", "(", "r", "+", "1", ")", "*", "GRID_DX", ",", "(", "c", "+", "1", ")", "*", "GRID_DY", ",", "-", "1", ")", ")" ]

[ "Raises", "a", "ValueError", "if", "any", "arguments", "have", "the", "incorrect", "types" ]

[ "def", "_validate_plot_inputs", "(", "workspaces", ",", "spectrum_nums", ",", "wksp_indices", ",", "tiled", "=", "False", ",", "overplot", "=", "False", ")", ":", "if", "spectrum_nums", "is", "not", "None", "and", "wksp_indices", "is", "not", "None", ":", "raise", "ValueError", "(", "\"Both spectrum_nums and wksp_indices supplied. \"", "\"Please supply only 1.\"", ")", "if", "tiled", "and", "overplot", ":", "raise", "ValueError", "(", "\"Both tiled and overplot flags set to true. \"", "\"Please set only one to true.\"", ")", "raise_if_not_sequence", "(", "workspaces", ",", "'workspaces'", ",", "MatrixWorkspace", ")", "if", "spectrum_nums", "is", "not", "None", ":", "raise_if_not_sequence", "(", "spectrum_nums", ",", "'spectrum_nums'", ")", "if", "wksp_indices", "is", "not", "None", ":", "raise_if_not_sequence", "(", "wksp_indices", ",", "'wksp_indices'", ")" ]

[ "Constructor", "." ]

[ "def", "__init__", "(", "self", ",", "expected_output", ")", ":", "self", ".", "_expected_output", "=", "expected_output" ]

[ "Creates", "and", "*", "returns", "*", "a", "ParseError", "for", "the", "previously", "read", "token", "." ]

[ "def", "ParseErrorPreviousToken", "(", "self", ",", "message", ")", ":", "return", "ParseError", "(", "message", ",", "self", ".", "_previous_line", "+", "1", ",", "self", ".", "_previous_column", "+", "1", ")" ]

[ "Pop", "the", "next", "method", "from", "our", "call", "queue", "." ]

[ "def", "_PopNextMethod", "(", "self", ")", ":", "try", ":", "return", "self", ".", "_call_queue", ".", "popleft", "(", ")", "except", "IndexError", ":", "raise", "UnexpectedMethodCallError", "(", "self", ",", "None", ")" ]

[ "Get", "year", "from", "log", "file", "system", "timestamp" ]

[ "def", "get_log_created_year", "(", "input_file", ")", ":", "log_created_time", "=", "os", ".", "path", ".", "getctime", "(", "input_file", ")", "log_created_year", "=", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "log_created_time", ")", ".", "year", "return", "log_created_year" ]

[ "Documents", "a", "non", "-", "data", "driven", "method" ]

[ "def", "document_custom_method", "(", "section", ",", "method_name", ",", "method", ")", ":", "document_custom_signature", "(", "section", ",", "method_name", ",", "method", ")", "method_intro_section", "=", "section", ".", "add_new_section", "(", "'method-intro'", ")", "method_intro_section", ".", "writeln", "(", "''", ")", "doc_string", "=", "inspect", ".", "getdoc", "(", "method", ")", "if", "doc_string", "is", "not", "None", ":", "method_intro_section", ".", "style", ".", "write_py_doc_string", "(", "doc_string", ")" ]

[ "domain_tan", "(", "eps", ")", "=", "true", "where", "abs", "(", "cos", "(", "x", "))", "<", "eps", ")" ]

[ "def", "__init__", "(", "self", ",", "eps", ")", ":", "self", ".", "eps", "=", "eps" ]

[ "Returns", "the", "QueueRunner", "for", "the", "chief", "to", "execute", "." ]

[ "def", "get_chief_queue_runner", "(", "self", ")", ":", "if", "self", ".", "_gradients_applied", "is", "False", ":", "raise", "ValueError", "(", "\"Should be called after apply_gradients().\"", ")", "return", "self", ".", "_chief_queue_runner" ]

[ "Check", "if", "we", "have", "seen", "the", "opening", "brace", "for", "the", "innermost", "block", "." ]

[ "def", "SeenOpenBrace", "(", "self", ")", ":", "return", "(", "not", "self", ".", "stack", ")", "or", "self", ".", "stack", "[", "-", "1", "]", ".", "seen_open_brace" ]

[ "Updates", "references", "to", "uniform_unit_scaling_initializer", "." ]

[ "def", "_add_uniform_scaling_initializer_transformer", "(", "parent", ",", "node", ",", "full_name", ",", "name", ",", "logs", ")", ":", "for", "keyword_arg", "in", "node", ".", "keywords", ":", "if", "keyword_arg", ".", "arg", "==", "\"factor\"", ":", "keyword_arg", ".", "arg", "=", "\"scale\"", "distribution_value", "=", "\"\\\"uniform\\\"\"", "# Parse with pasta instead of ast to avoid emitting a spurious trailing \\n.", "ast_value", "=", "pasta", ".", "parse", "(", "distribution_value", ")", "node", ".", "keywords", ".", "append", "(", "ast", ".", "keyword", "(", "arg", "=", "\"distribution\"", ",", "value", "=", "ast_value", ")", ")", "lineno", "=", "node", ".", "func", ".", "value", ".", "lineno", "col_offset", "=", "node", ".", "func", ".", "value", ".", "col_offset", "node", ".", "func", ".", "value", "=", "ast_edits", ".", "full_name_node", "(", "\"tf.compat.v1.keras.initializers\"", ")", "node", ".", "func", ".", "value", ".", "lineno", "=", "lineno", "node", ".", "func", ".", "value", ".", "col_offset", "=", "col_offset", "node", ".", "func", ".", "attr", "=", "\"VarianceScaling\"", "return", "node" ]

[ "Returns", "new", "TPM2_PolicyCounterTimer_REQUEST", "object", "constructed", "from", "its", "marshaled", "representation", "in", "the", "given", "TpmBuffer", "buffer" ]

[ "def", "fromTpm", "(", "buf", ")", ":", "return", "buf", ".", "createObj", "(", "TPM2_PolicyCounterTimer_REQUEST", ")" ]

[ "Clears", "a", "range", "of", "lines", "for", "multi", "-", "line", "comments", "." ]

[ "def", "RemoveMultiLineCommentsFromRange", "(", "lines", ",", "begin", ",", "end", ")", ":", "# Having // dummy comments makes the lines non-empty, so we will not get", "# unnecessary blank line warnings later in the code.", "for", "i", "in", "range", "(", "begin", ",", "end", ")", ":", "lines", "[", "i", "]", "=", "'// dummy'" ]

[ "Fetch", "at", "most", "this", "many", "resources", "per", "service", "request", "." ]

[ "def", "page_size", "(", "self", ",", "count", ")", ":", "return", "self", ".", "_clone", "(", "page_size", "=", "count", ")" ]

[ "Unstack", "also", "known", "as", "pivot", "Series", "with", "MultiIndex", "to", "produce", "DataFrame", "." ]

[ "def", "unstack", "(", "self", ",", "level", "=", "-", "1", ",", "fill_value", "=", "None", ")", "->", "DataFrame", ":", "from", "pandas", ".", "core", ".", "reshape", ".", "reshape", "import", "unstack", "return", "unstack", "(", "self", ",", "level", ",", "fill_value", ")" ]

[ "Broadcast", "any", "number", "of", "arrays", "against", "each", "other", "." ]

[ "def", "broadcast_arrays", "(", "*", "args", ")", ":", "args", "=", "map", "(", "np", ".", "asarray", ",", "args", ")", "shapes", "=", "[", "x", ".", "shape", "for", "x", "in", "args", "]", "if", "len", "(", "set", "(", "shapes", ")", ")", "==", "1", ":", "# Common case where nothing needs to be broadcasted.", "return", "args", "shapes", "=", "[", "list", "(", "s", ")", "for", "s", "in", "shapes", "]", "strides", "=", "[", "list", "(", "x", ".", "strides", ")", "for", "x", "in", "args", "]", "nds", "=", "[", "len", "(", "s", ")", "for", "s", "in", "shapes", "]", "biggest", "=", "max", "(", "nds", ")", "# Go through each array and prepend dimensions of length 1 to each of the", "# shapes in order to make the number of dimensions equal.", "for", "i", "in", "range", "(", "len", "(", "args", ")", ")", ":", "diff", "=", "biggest", "-", "nds", "[", "i", "]", "if", "diff", ">", "0", ":", "shapes", "[", "i", "]", "=", "[", "1", "]", "*", "diff", "+", "shapes", "[", "i", "]", "strides", "[", "i", "]", "=", "[", "0", "]", "*", "diff", "+", "strides", "[", "i", "]", "# Chech each dimension for compatibility. A dimension length of 1 is", "# accepted as compatible with any other length.", "common_shape", "=", "[", "]", "for", "axis", "in", "range", "(", "biggest", ")", ":", "lengths", "=", "[", "s", "[", "axis", "]", "for", "s", "in", "shapes", "]", "unique", "=", "set", "(", "lengths", "+", "[", "1", "]", ")", "if", "len", "(", "unique", ")", ">", "2", ":", "# There must be at least two non-1 lengths for this axis.", "raise", "ValueError", "(", "\"shape mismatch: two or more arrays have \"", "\"incompatible dimensions on axis %r.\"", "%", "(", "axis", ",", ")", ")", "elif", "len", "(", "unique", ")", "==", "2", ":", "# There is exactly one non-1 length. The common shape will take this", "# value.", "unique", ".", "remove", "(", "1", ")", "new_length", "=", "unique", ".", "pop", "(", ")", "common_shape", ".", "append", "(", "new_length", ")", "# For each array, if this axis is being broadcasted from a length of", "# 1, then set its stride to 0 so that it repeats its data.", "for", "i", "in", "range", "(", "len", "(", "args", ")", ")", ":", "if", "shapes", "[", "i", "]", "[", "axis", "]", "==", "1", ":", "shapes", "[", "i", "]", "[", "axis", "]", "=", "new_length", "strides", "[", "i", "]", "[", "axis", "]", "=", "0", "else", ":", "# Every array has a length of 1 on this axis. Strides can be left", "# alone as nothing is broadcasted.", "common_shape", ".", "append", "(", "1", ")", "# Construct the new arrays.", "broadcasted", "=", "[", "as_strided", "(", "x", ",", "shape", "=", "sh", ",", "strides", "=", "st", ")", "for", "(", "x", ",", "sh", ",", "st", ")", "in", "zip", "(", "args", ",", "shapes", ",", "strides", ")", "]", "return", "broadcasted" ]

[ "return", "all", "the", "gt", "data", "in", "a", "record" ]

[ "def", "getRecord", "(", "data", ",", "total", "=", "-", "1", ",", "pos", "=", "True", ",", "pose", "=", "False", ",", "facial", "=", "False", ")", ":", "if", "total", "==", "-", "1", ":", "total", "=", "data", ".", "getTotal", "(", ")", "else", ":", "total", "=", "min", "(", "data", ".", "getTotal", "(", ")", ",", "total", ")", "arrPos", "=", "numpy", ".", "zeros", "(", "total", ",", "dtype", "=", "[", "(", "\"id\"", ",", "numpy", ".", "int32", ")", ",", "(", "\"name\"", ",", "object", ")", ",", "(", "\"bbox\"", ",", "list", ")", "]", ")", "if", "facial", ":", "arrPos", "=", "numpy", ".", "zeros", "(", "total", ",", "dtype", "=", "[", "(", "\"id\"", ",", "numpy", ".", "int32", ")", ",", "(", "\"name\"", ",", "object", ")", ",", "(", "\"bbox\"", ",", "list", ")", ",", "(", "\"facial\"", ",", "object", ")", "]", ")", "if", "pose", ":", "arrPos", "=", "numpy", ".", "zeros", "(", "total", ",", "dtype", "=", "[", "(", "\"id\"", ",", "numpy", ".", "int32", ")", ",", "(", "\"name\"", ",", "object", ")", ",", "(", "\"bbox\"", ",", "list", ")", ",", "(", "\"facial\"", ",", "object", ")", ",", "(", "\"pose\"", ",", "object", ")", "]", ")", "for", "i", "in", "range", "(", "total", ")", ":", "arrPos", "[", "i", "]", "[", "\"id\"", "]", "=", "i", "arrPos", "[", "i", "]", "[", "\"name\"", "]", "=", "data", ".", "getImageName", "(", "i", ")", "arrPos", "[", "i", "]", "[", "\"bbox\"", "]", "=", "data", ".", "getBBox", "(", "i", ")", "if", "pose", ":", "arrPos", "[", "i", "]", "[", "\"pose\"", "]", "=", "data", ".", "getPose", "(", "i", ")", "if", "facial", ":", "arrPos", "[", "i", "]", "[", "\"facial\"", "]", "=", "data", ".", "getFacial", "(", "i", ")", "return", "arrPos" ]